feat: Add custom equality checker support to ValueSignal (#23611)

* feat: Add custom equality checker support to ValueSignal

Optimize ValueSignal to skip updates when the new value equals the
current value, and allow customization of equality logic.

Changes:
- Add SerializableBiPredicate<T, T> field for custom equality checking
- Add constructor accepting custom equality checker (defaults to Objects::equals)
- Update set() to skip updates when values are equal per equality checker
- Update update() to use equality checker instead of reference equality
- Add comprehensive tests for default and custom equality checkers

Fixes #23588

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

* Javadoc, replace if value differs, extra test

* improve javadoc

* fix test

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: mshabarov

flow-server/src/main/java/com/vaadin/flow/signals/local/ValueSignal.java

@@ -20,6 +20,7 @@
 
 import org.jspecify.annotations.Nullable;
 
+import com.vaadin.flow.function.SerializableBiPredicate;
 import com.vaadin.flow.function.SerializableConsumer;
 import com.vaadin.flow.server.VaadinSession;
 import com.vaadin.flow.signals.Signal;
@@ -57,6 +58,7 @@ public class ValueSignal<T> extends AbstractLocalSignal<T> {
     private boolean modifyRunning = false;
     private transient boolean modifyUsed = false;
     private transient boolean usedWithoutSessionLock = false;
+    private final SerializableBiPredicate<T, T> equalityChecker;
 
     /**
      * Creates a new value signal with the given initial value.
@@ -65,7 +67,29 @@ public class ValueSignal<T> extends AbstractLocalSignal<T> {
      *            the initial value, may be <code>null</code>
      */
     public ValueSignal(@Nullable T initialValue) {
+        this(initialValue, Objects::equals);
+    }
+
+    /**
+     * Creates a new value signal with the given initial value and a custom
+     * equality checker.
+     * <p>
+     * The equality checker is used to determine if a new value is equal to the
+     * current value. If the equality checker returns {@code true}, the value
+     * update is skipped, and no change notification is triggered, i.e., no
+     * dependent effect function is triggered.
+     *
+     * @param initialValue
+     *            the initial value, may be <code>null</code>
+     * @param equalityChecker
+     *            the predicate used to compare values for equality, not
+     *            <code>null</code>
+     */
+    public ValueSignal(@Nullable T initialValue,
+            SerializableBiPredicate<T, T> equalityChecker) {
         super(initialValue);
+        this.equalityChecker = Objects.requireNonNull(equalityChecker,
+                "Equality checker must not be null");
     }
 
     @Override
@@ -104,8 +128,12 @@ protected void checkPreconditions() {
     /**
      * Sets the value of this signal.
      * <p>
-     * Setting a new value will trigger effect functions that have reads from
-     * this signal.
+     * If the new value is not equal to the current value, the value is set and
+     * effect functions that have reads from this signal are triggered. If the
+     * values are equal, no change is made and effect functions are not
+     * triggered. The equality checker provided in the constructor is used to
+     * compare the values and defaults to
+     * {@link Objects#equals(Object, Object)}.
      *
      * @param value
      *            the value to set
@@ -115,7 +143,9 @@ public void set(@Nullable T value) {
         try {
             checkPreconditions();
 
-            setSignalValue(value);
+            if (!equalityChecker.test(value, getSignalValue())) {
+                setSignalValue(value);
+            }
         } finally {
             unlock();
         }
@@ -127,8 +157,12 @@ public void set(@Nullable T value) {
      * counterpart to
      * {@link java.util.concurrent.atomic.AtomicReference#compareAndSet(Object, Object)}.
      * <p>
-     * Comparison between the expected value and the new value is performed
-     * using {@link #equals(Object)}.
+     * If the expected value matches and the new value differs from the old
+     * value, the value is set and effect functions are triggered. If the
+     * expected value matches but the new value equals the old value, no change
+     * is made and effect functions are not triggered. The equality checker
+     * provided in the constructor is used to compare the expected value with
+     * the current value, and to compare the new value with the old value.
      *
      * @param expectedValue
      *            the expected value
@@ -142,8 +176,10 @@ public boolean replace(@Nullable T expectedValue, @Nullable T newValue) {
         try {
             checkPreconditions();
 
-            if (Objects.equals(expectedValue, getSignalValue())) {
-                setSignalValue(newValue);
+            if (equalityChecker.test(expectedValue, getSignalValue())) {
+                if (!equalityChecker.test(newValue, getSignalValue())) {
+                    setSignalValue(newValue);
+                }
                 return true;
             } else {
                 return false;
@@ -164,6 +200,10 @@ public boolean replace(@Nullable T expectedValue, @Nullable T newValue) {
      * would occur after the original transaction has already been committed.
      * For this reason, the whole operation completely bypasses all transaction
      * handling.
+     * <p>
+     * If the new value is equal to the current value, no change is made and
+     * effect functions are not triggered. The equality checker provided in the
+     * constructor is used to compare the values.
      *
      * @param updater
      *            the value update callback, not <code>null</code>
@@ -177,7 +217,7 @@ public boolean replace(@Nullable T expectedValue, @Nullable T newValue) {
 
             T oldValue = getSignalValue();
             T newValue = updater.update(oldValue);
-            if (newValue != oldValue) {
+            if (!equalityChecker.test(newValue, oldValue)) {
                 setSignalValue(newValue);
             }