react-native-onyx 3.0.70 → 3.0.72

package/dist/OnyxUtils.js

@@ -454,6 +454,16 @@ function keysChanged(collectionKey, partialCollection, partialPreviousCollection
     const cachedCollection = getCachedCollection(collectionKey);
     const previousCollection = partialPreviousCollection !== null && partialPreviousCollection !== void 0 ? partialPreviousCollection : {};
     const changedMemberKeys = Object.keys(partialCollection !== null && partialCollection !== void 0 ? partialCollection : {});
+    // Add or remove the keys from the recentlyAccessedKeys list
+    for (const memberKey of changedMemberKeys) {
+        const value = partialCollection === null || partialCollection === void 0 ? void 0 : partialCollection[memberKey];
+        if (value !== null && value !== undefined) {
+            OnyxCache_1.default.addLastAccessedKey(memberKey, false);
+        }
+        else {
+            OnyxCache_1.default.removeLastAccessedKey(memberKey);
+        }
+    }
     // Use indexed lookup instead of scanning all subscribers.
     // We need subscribers for: (1) the collection key itself, and (2) individual changed member keys.
     const collectionSubscriberIDs = (_a = onyxKeyToSubscriptionIDs.get(collectionKey)) !== null && _a !== void 0 ? _a : [];
@@ -478,12 +488,20 @@ function keysChanged(collectionKey, partialCollection, partialPreviousCollection
                 subscriber.callback(cachedCollection, subscriber.key, partialCollection);
                 continue;
             }
-            // Not using waitForCollectionCallback — notify per changed key
+            // Not using waitForCollectionCallback — notify per changed key.
+            // Re-check the subscription on each iteration because the callback may
+            // synchronously disconnect itself (removing it from callbackToStateMapping),
+            // in which case we must stop firing further callbacks for this subscriber.
             for (const dataKey of changedMemberKeys) {
+                const currentSubscriber = callbackToStateMapping[subID];
+                if (!currentSubscriber || typeof currentSubscriber.callback !== 'function') {
+                    break;
+                }
                 if (cachedCollection[dataKey] === previousCollection[dataKey]) {
                     continue;
                 }
-                subscriber.callback(cachedCollection[dataKey], dataKey);
+                const currentSubscriberCallback = currentSubscriber.callback;
+                currentSubscriberCallback(cachedCollection[dataKey], dataKey);
             }
         }
         catch (error) {
@@ -1135,15 +1153,43 @@ function multiSetWithRetry(data, retryAttempt) {
         }, {});
     }
     const keyValuePairsToSet = OnyxUtils.prepareKeyValuePairsForStorage(newData, true);
+    // Group collection members by their parent collection key so each collection can be notified
+    // via a single batched keysChanged() call instead of one keyChanged() per member. For each
+    // collection, `partial` holds the new values being set and `previous` holds the cached values
+    // from before the set, which keysChanged() uses to skip subscribers whose value didn't change.
+    const collectionBatches = new Map();
     for (const [key, value] of keyValuePairsToSet) {
         // When we use multiSet to set a key we want to clear the current delta changes from Onyx.merge that were queued
         // before the value was set. If Onyx.merge is currently reading the old value from storage, it will then not apply the changes.
         if (OnyxUtils.hasPendingMergeForKey(key)) {
             delete OnyxUtils.getMergeQueue()[key];
         }
-        // Update cache and optimistically inform subscribers
-        OnyxCache_1.default.set(key, value);
-        keyChanged(key, value);
+        const collectionKey = OnyxKeys_1.default.getCollectionKey(key);
+        if (collectionKey && OnyxKeys_1.default.isCollectionMemberKey(collectionKey, key)) {
+            // Capture the previous cached value BEFORE calling cache.set() so keysChanged()
+            // can diff old vs new per-member.
+            const previousValue = OnyxCache_1.default.get(key);
+            OnyxCache_1.default.set(key, value);
+            let batch = collectionBatches.get(collectionKey);
+            if (!batch) {
+                batch = { partial: {}, previous: {} };
+                collectionBatches.set(collectionKey, batch);
+            }
+            batch.partial[key] = value;
+            batch.previous[key] = previousValue;
+        }
+        else {
+            // Non-collection keys are notified inline (cache.set + keyChanged in iteration order)
+            // so re-entrant callbacks (e.g. Onyx.set inside a callback) see consistent cache
+            // and subscriber state, matching the original per-key notification semantics.
+            OnyxCache_1.default.set(key, value);
+            keyChanged(key, value);
+        }
+    }
+    // One keysChanged() per collection — fires each collection-level subscriber once and lets
+    // keysChanged() internally decide which individual member subscribers need notification.
+    for (const [collectionKey, batch] of collectionBatches) {
+        keysChanged(collectionKey, batch.partial, batch.previous);
     }
     const keyValuePairsToStore = keyValuePairsToSet.filter((keyValuePair) => {
         const [key] = keyValuePair;

package/dist/useOnyx.js

@@ -96,6 +96,9 @@ function useOnyx(key, options, dependencies = []) {
     // after cleanup), so the hook automatically enters first-connection mode for the new key without any
     // explicit reset logic — eliminating the race condition where cleanup could clobber a boolean flag.
     const connectedKeyRef = (0, react_1.useRef)(null);
+    // Tracks whether the hook has completed its initial mount subscription.
+    // Unlike connectedKeyRef (which gets nulled by cleanup), this persists across re-subscriptions.
+    const hasMountedRef = (0, react_1.useRef)(false);
     // Indicates if the hook is connecting to an Onyx key.
     const isConnectingRef = (0, react_1.useRef)(false);
     // Stores the `onStoreChange()` function, which can be used to trigger a `getSnapshot()` update when desired.
@@ -211,11 +214,19 @@ function useOnyx(key, options, dependencies = []) {
     const subscribe = (0, react_1.useCallback)((onStoreChange) => {
         // Reset internal state so the hook properly transitions through loading
         // for the new key instead of preserving stale state from the previous one.
-        previousValueRef.current = null;
-        newValueRef.current = null;
+        // Only reset when the key has actually changed (not on initial mount).
+        if (hasMountedRef.current) {
+            previousValueRef.current = null;
+            newValueRef.current = null;
+            sourceValueRef.current = undefined;
+            resultRef.current = [undefined, { status: (options === null || options === void 0 ? void 0 : options.initWithStoredValues) === false ? 'loaded' : 'loading' }];
+        }
+        // Force a cache re-read on every (re)subscription so any side effects from
+        // subscribeToKey (e.g. addNullishStorageKey for skippable collection member ids)
+        // are reflected in the next getSnapshot. Resetting this flag does not change
+        // resultRef by itself, so it doesn't cause an extra mount render.
         shouldGetCachedValueRef.current = true;
-        sourceValueRef.current = undefined;
-        resultRef.current = [undefined, { status: (options === null || options === void 0 ? void 0 : options.initWithStoredValues) === false ? 'loaded' : 'loading' }];
+        hasMountedRef.current = true;
         isConnectingRef.current = true;
         onStoreChangeFnRef.current = onStoreChange;
         connectionRef.current = OnyxConnectionManager_1.default.connect({

package/package.json

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