Memoize shallowEqual verdicts by object identity in useOnyx

Author: TMisiukiewicz

lib/useOnyx.ts

@@ -28,6 +28,34 @@ type UseOnyxOptions<TKey extends OnyxKey, TReturnValue> = {
     selector?: UseOnyxSelector<TKey, TReturnValue>;
 };
 
+// Memoizes shallowEqual verdicts by the identity of the compared objects. Onyx values are
+// treated as immutable (merge/set replace objects, never mutate), so a (prev, next) reference
+// pair always yields the same verdict. In the hot case — N no-selector hooks on the same big
+// key — every hook compares the exact same two cache-owned objects, so the first hook pays for
+// the O(keys) walk and the rest resolve in O(1). WeakMap keys make stale entries impossible to
+// read (lookup requires holding both exact objects) and let GC reclaim them.
+const shallowEqualVerdicts = new WeakMap<object, WeakMap<object, boolean>>();
+
+// Identity-pair-memoized shallowEqual: same (prev, next) references → cached verdict, no walk.
+function memoizedShallowEqual(a: unknown, b: unknown): boolean {
+    // Only object pairs are memoizable (WeakMap keys) — anything else is O(1) to compare anyway.
+    if (typeof a !== 'object' || a === null || typeof b !== 'object' || b === null) {
+        return shallowEqual(a, b);
+    }
+    let verdictsForA = shallowEqualVerdicts.get(a);
+    if (!verdictsForA) {
+        verdictsForA = new WeakMap();
+        shallowEqualVerdicts.set(a, verdictsForA);
+    }
+    const cachedVerdict = verdictsForA.get(b);
+    if (cachedVerdict !== undefined) {
+        return cachedVerdict;
+    }
+    const verdict = shallowEqual(a, b);
+    verdictsForA.set(b, verdict);
+    return verdict;
+}
+
 type FetchStatus = 'loading' | 'loaded';
 
 type ResultMetadata = {
@@ -201,9 +229,11 @@ function useOnyx<TKey extends OnyxKey, TReturnValue = OnyxValue<TKey>>(
 
         // shallowEqual checks === first (O(1) for frozen snapshots and stable selector references),
         // then falls back to comparing top-level properties for individual keys that may have
-        // new references with equivalent content.
+        // new references with equivalent content. The comparison is memoized by object identity
+        // (see `memoizedShallowEqual`) so N hooks comparing the same two cache objects pay for
+        // one walk in total instead of one walk each.
         // Normalize null to undefined to ensure consistent comparison (both represent "no value").
-        const areValuesEqual = shallowEqual(previousValueRef.current ?? undefined, newValueRef.current ?? undefined);
+        const areValuesEqual = memoizedShallowEqual(previousValueRef.current ?? undefined, newValueRef.current ?? undefined);
 
         // We update the cached value and the result in the following conditions:
         // We will update the cached value and the result in any of the following situations: