Merge branch 'persistence/persistableFixableAtom-areEqualFunction' into rubenthoms/persistence/module-states

Author: jorgenherje

frontend/src/framework/utils/atomUtils.ts

@@ -90,6 +90,12 @@ type PersistableFixableAtomOptionsWithPrecompute<TValue, TPrecomputedValue> = {
      */
     initialValue: TValue;
 
+    /**
+     * A function to compare two values for equality.
+     * This is used to optimize updates by preventing unnecessary re-renders.
+     */
+    areEqualFunction?: (a: TValue, b: TValue) => boolean;
+
     precomputeFunction: (options: { value: TValue; get: Getter }) => TPrecomputedValue;
     /**
      * A function to validate whether the given value is valid in the current application context.
@@ -123,6 +129,12 @@ type PersistableFixableAtomOptionsWithoutPrecompute<TValue> = {
      */
     initialValue: TValue;
 
+    /**
+     * A function to compare two values for equality.
+     * This is used to optimize updates by preventing unnecessary re-renders.
+     */
+    areEqualFunction?: (a: TValue, b: TValue) => boolean;
+
     /**
      * A function to validate whether the given value is valid in the current application context.
      * Called whenever the atom is read to determine if a persisted value is still valid.
@@ -226,20 +238,28 @@ export function persistableFixableAtom<TValue, TPrecomputedValue>(
                 _source: internalState._source,
             };
         },
-        (_, set, update: TValue | PersistableAtomState<TValue>) => {
+        (get, set, update: TValue | PersistableAtomState<TValue>) => {
+            const areEqualFunc = options.areEqualFunction;
+            const currentState = get(internalStateAtom);
+
             if (isInternalState(update)) {
-                set(internalStateAtom, {
-                    ...update,
-                });
+                if (areEqualFunc && areEqualFunc(currentState.value, update.value)) {
+                    // If values are equal, preserve value reference, but update source if different
+                    if (currentState._source !== update._source) {
+                        set(internalStateAtom, { value: currentState.value, _source: update._source });
+                    }
+                    return;
+                }
+                set(internalStateAtom, { ...update });
                 return;
             }
 
-            const newInternalState: PersistableAtomState<TValue> = {
-                value: update,
-                _source: Source.USER,
-            };
-
-            set(internalStateAtom, newInternalState);
+            // Handle direct value updates (non-internal state)
+            const value =
+                areEqualFunc && areEqualFunc(currentState.value, update)
+                    ? currentState.value // Preserve reference when equal
+                    : update;
+            set(internalStateAtom, { value, _source: Source.USER });
         },
     );