feat: add support for accepting hidden fields in Binder (#24139)

Adds setAcceptHiddenFields(boolean) to Binder.
setAcceptHiddenFields(true) makes Binder apply bindings for hidden
fields by default in same way as with pre-Vaadin 25.

PartOf: #24109

Author: tltv

flow-data/src/main/java/com/vaadin/flow/data/binder/Binder.java

@@ -2011,9 +2011,13 @@ private void removeFromChangedBindingsIfReverted(
         }
 
         public SerializablePredicate<Binding<BEAN, TARGET>> getIsAppliedPredicate() {
-            return isAppliedPredicate == null
-                    ? Binding.super.getIsAppliedPredicate()
-                    : isAppliedPredicate;
+            if (isAppliedPredicate != null) {
+                return isAppliedPredicate;
+            }
+            if (getBinder().isApplyBindingsToHiddenFields()) {
+                return binding -> true;
+            }
+            return Binding.super.getIsAppliedPredicate();
         }
 
         @Override
@@ -2156,6 +2160,8 @@ void setIdentity() {
 
     private boolean changeDetectionEnabled = false;
 
+    private boolean applyBindingsToHiddenFields = false;
+
     private ValueSignal<BinderValidationStatus<BEAN>> binderValidationStatusSignal;
 
     /**
@@ -4324,6 +4330,40 @@ public boolean isValidatorsDisabled() {
         return validatorsDisabled;
     }
 
+    /**
+     * Sets whether all bindings of this Binder should be applied to fields that
+     * are not currently visible. By default, bindings whose field is a
+     * {@link Component} with {@link Component#isVisible()} returning
+     * {@literal false} are skipped during validation and when writing values to
+     * the bean. Enabling this setting restores the pre-Vaadin 25 behavior where
+     * hidden fields are validated and written just like visible ones.
+     * <p>
+     * This is a Binder-level fallback: any binding that has its own predicate
+     * set via {@link Binding#setIsAppliedPredicate(SerializablePredicate)}
+     * continues to use that predicate and is not affected by this flag.
+     * <p>
+     * Defaults to {@literal false}.
+     *
+     * @param applyBindingsToHiddenFields
+     *            {@literal true} to make all bindings apply to hidden fields,
+     *            {@literal false} to skip hidden fields (the default)
+     */
+    public void setApplyBindingsToHiddenFields(
+            boolean applyBindingsToHiddenFields) {
+        this.applyBindingsToHiddenFields = applyBindingsToHiddenFields;
+    }
+
+    /**
+     * Returns whether all bindings of this Binder apply to fields that are not
+     * currently visible.
+     *
+     * @return {@literal true} if bindings are applied to hidden fields,
+     *         {@literal false} if hidden fields are skipped (the default)
+     */
+    public boolean isApplyBindingsToHiddenFields() {
+        return applyBindingsToHiddenFields;
+    }
+
     /**
      * Control whether bound fields implementing {@link HasValidator} subscribe
      * for field's {@code ValidationStatusChangeEvent}s and will

flow-data/src/test/java/com/vaadin/flow/data/binder/BinderTest.java

@@ -956,6 +956,67 @@ void withValidator_isAppliedIsEvaluated() {
         assertTrue(binder.isValid());
     }
 
+    @Test
+    void setApplyBindingsToHiddenFields_defaultsToFalse_appliesToHiddenFieldsWhenEnabled() {
+        Binding<Person, String> nameBinding = binder.forField(nameField)
+                .withValidator(name -> false, "")
+                .bind(Person::getFirstName, Person::setFirstName);
+        binder.setBean(item);
+
+        assertFalse(binder.isApplyBindingsToHiddenFields());
+
+        ((Component) nameBinding.getField()).setVisible(false);
+        assertTrue(binder.isValid(),
+                "Hidden field should be skipped by default");
+
+        binder.setApplyBindingsToHiddenFields(true);
+        assertFalse(binder.isValid(),
+                "Hidden field should be validated when applyBindingsToHiddenFields is true");
+
+        nameBinding.setIsAppliedPredicate(p -> false);
+        assertTrue(binder.isValid(),
+                "Per-binding predicate should override Binder-level applyBindingsToHiddenFields");
+    }
+
+    @Test
+    void writeBean_applyBindingsToHiddenFields_writesHiddenFieldsWhenEnabled()
+            throws ValidationException {
+        Binding<Person, String> nameBinding = binder.forField(nameField)
+                .bind(Person::getFirstName, Person::setFirstName);
+        binder.readBean(item);
+
+        nameField.setValue("NewName");
+        ((Component) nameBinding.getField()).setVisible(false);
+
+        binder.writeBean(item);
+        assertEquals("Johannes", item.getFirstName(),
+                "Hidden field should not be written by default");
+
+        binder.setApplyBindingsToHiddenFields(true);
+        binder.writeBean(item);
+        assertEquals("NewName", item.getFirstName(),
+                "Hidden field should be written when applyBindingsToHiddenFields is true");
+    }
+
+    @Test
+    void writeBeanIfValid_applyBindingsToHiddenFields_writesHiddenFieldsWhenEnabled() {
+        Binding<Person, String> nameBinding = binder.forField(nameField)
+                .bind(Person::getFirstName, Person::setFirstName);
+        binder.readBean(item);
+
+        nameField.setValue("NewName");
+        ((Component) nameBinding.getField()).setVisible(false);
+
+        assertTrue(binder.writeBeanIfValid(item));
+        assertEquals("Johannes", item.getFirstName(),
+                "Hidden field should not be written by default");
+
+        binder.setApplyBindingsToHiddenFields(true);
+        assertTrue(binder.writeBeanIfValid(item));
+        assertEquals("NewName", item.getFirstName(),
+                "Hidden field should be written when applyBindingsToHiddenFields is true");
+    }
+
     @Test
     void writeBean_isAppliedIsEvaluated() {
         AtomicInteger invokes = new AtomicInteger();