react-native-onyx 3.0.92 → 3.0.94

package/dist/OnyxCache.js

@@ -286,7 +286,7 @@ class OnyxCache {
         // Initialize frozen snapshots for collection keys
         for (const collectionKey of collectionKeys) {
             if (!this.collectionSnapshots.has(collectionKey)) {
-                this.collectionSnapshots.set(collectionKey, Object.freeze({}));
+                this.collectionSnapshots.set(collectionKey, FROZEN_EMPTY_COLLECTION);
             }
         }
     }
@@ -302,6 +302,7 @@ class OnyxCache {
         const previousSnapshot = this.collectionSnapshots.get(collectionKey);
         const members = {};
         let hasMemberChanges = false;
+        let hasMembers = false;
         // Use the indexed forward lookup for O(collectionMembers) iteration.
         // Falls back to scanning all storageKeys if the index isn't populated yet.
         const memberKeys = OnyxKeys_1.default.getMembersOfCollection(collectionKey);
@@ -318,6 +319,7 @@ class OnyxCache {
             // and should not be included in the frozen collection snapshot.
             if (val !== undefined && val !== null) {
                 members[key] = val;
+                hasMembers = true;
                 // Check if this member's reference changed from the old snapshot
                 if (!hasMemberChanges && (!previousSnapshot || previousSnapshot[key] !== val)) {
                     hasMemberChanges = true;
@@ -342,6 +344,13 @@ class OnyxCache {
         if (!hasMemberChanges && previousSnapshot) {
             return;
         }
+        // When the collection has no members, reuse one shared empty object for every empty
+        // collection. That way reads can tell a collection is empty with a quick `===` check
+        // instead of looping over its keys every time.
+        if (!hasMembers) {
+            this.collectionSnapshots.set(collectionKey, FROZEN_EMPTY_COLLECTION);
+            return;
+        }
         Object.freeze(members);
         this.collectionSnapshots.set(collectionKey, members);
     }
@@ -356,17 +365,18 @@ class OnyxCache {
             this.dirtyCollections.delete(collectionKey);
         }
         const snapshot = this.collectionSnapshots.get(collectionKey);
-        if (utils_1.default.isEmptyObject(snapshot)) {
-            // We check storageKeys.size (not collection-specific keys) to distinguish
-            // "init complete, this collection is genuinely empty" from "init not done yet."
-            // During init, setAllKeys loads ALL keys at once — so if any key exists,
-            // the full storage picture is loaded and an empty collection is truly empty.
-            // Returning undefined before init prevents subscribers from seeing a false empty state.
-            if (this.storageKeys.size > 0) {
-                return FROZEN_EMPTY_COLLECTION;
-            }
+        // We never stored anything for this collection key.
+        if (snapshot === undefined) {
             return undefined;
         }
+        // The collection is empty (it holds our shared empty object). But "empty" is ambiguous
+        // during startup: we can't tell an actually-empty collection apart from one whose data
+        // hasn't loaded yet. Once any key exists, we know setAllKeys has run and loaded everything,
+        // so an empty collection really is empty. Before that, return undefined so subscribers
+        // don't briefly see a collection as empty when it just hasn't loaded.
+        if (snapshot === FROZEN_EMPTY_COLLECTION) {
+            return this.storageKeys.size > 0 ? FROZEN_EMPTY_COLLECTION : undefined;
+        }
         return snapshot;
     }
 }

package/dist/memoizedShallowEqual.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Identity-pair-memoized shallowEqual: same (a, b) references → cached verdict, no walk.
+ */
+declare function memoizedShallowEqual(a: unknown, b: unknown): boolean;
+export default memoizedShallowEqual;

package/dist/memoizedShallowEqual.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fast_equals_1 = require("fast-equals");
+/**
+ * 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();
+/**
+ * Identity-pair-memoized shallowEqual: same (a, b) references → cached verdict, no walk.
+ */
+function memoizedShallowEqual(a, b) {
+    // 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 (0, fast_equals_1.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 = (0, fast_equals_1.shallowEqual)(a, b);
+    verdictsForA.set(b, verdict);
+    return verdict;
+}
+exports.default = memoizedShallowEqual;

package/dist/useOnyx.js

@@ -42,6 +42,7 @@ const OnyxCache_1 = __importStar(require("./OnyxCache"));
 const OnyxConnectionManager_1 = __importDefault(require("./OnyxConnectionManager"));
 const OnyxUtils_1 = __importDefault(require("./OnyxUtils"));
 const OnyxSnapshotCache_1 = __importDefault(require("./OnyxSnapshotCache"));
+const memoizedShallowEqual_1 = __importDefault(require("./memoizedShallowEqual"));
 const useLiveRef_1 = __importDefault(require("./useLiveRef"));
 function useOnyx(key, options, dependencies = []) {
     const connectionRef = (0, react_1.useRef)(null);
@@ -170,9 +171,11 @@ function useOnyx(key, options, dependencies = []) {
         }
         // 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 = (0, fast_equals_1.shallowEqual)((_a = previousValueRef.current) !== null && _a !== void 0 ? _a : undefined, (_b = newValueRef.current) !== null && _b !== void 0 ? _b : undefined);
+        const areValuesEqual = (0, memoizedShallowEqual_1.default)((_a = previousValueRef.current) !== null && _a !== void 0 ? _a : undefined, (_b = newValueRef.current) !== null && _b !== void 0 ? _b : 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:
         // - The previously cached value is different from the new value.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-onyx",
-  "version": "3.0.92",
+  "version": "3.0.94",
   "author": "Expensify, Inc.",
   "homepage": "https://expensify.com",
   "description": "State management for React Native",