react-native-onyx 2.0.137 → 2.0.139

package/dist/Onyx.js

@@ -155,6 +155,13 @@ function disconnect(connection) {
  * @param options optional configuration object
  */
 function set(key, value, options) {
+    return setInternal(key, value, options);
+}
+/**
+ * @param isFromUpdate - Whether this call originates from Onyx.update()
+ * When isFromUpdate = true (called from Onyx.update()), useOnyx hook subscribers are batched to escape excessive re-renders in components
+ */
+function setInternal(key, value, options, isFromUpdate = false) {
     // When we use Onyx.set 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_1.default.hasPendingMergeForKey(key)) {
@@ -200,13 +207,13 @@ function set(key, value, options) {
     const hasChanged = (options === null || options === void 0 ? void 0 : options.skipCacheCheck) ? true : OnyxCache_1.default.hasValueChanged(key, valueWithoutNestedNullValues);
     OnyxUtils_1.default.logKeyChanged(OnyxUtils_1.default.METHOD.SET, key, value, hasChanged);
     // This approach prioritizes fast UI changes without waiting for data to be stored in device storage.
-    const updatePromise = OnyxUtils_1.default.broadcastUpdate(key, valueWithoutNestedNullValues, hasChanged);
+    const updatePromise = OnyxUtils_1.default.broadcastUpdate(key, valueWithoutNestedNullValues, hasChanged, isFromUpdate);
     // If the value has not changed or the key got removed, calling Storage.setItem() would be redundant and a waste of performance, so return early instead.
     if (!hasChanged) {
         return updatePromise;
     }
     return storage_1.default.setItem(key, valueWithoutNestedNullValues)
-        .catch((error) => OnyxUtils_1.default.evictStorageAndRetry(error, set, key, valueWithoutNestedNullValues))
+        .catch((error) => OnyxUtils_1.default.evictStorageAndRetry(error, setInternal, key, valueWithoutNestedNullValues, undefined, isFromUpdate))
         .then(() => {
         OnyxUtils_1.default.sendActionToDevTools(OnyxUtils_1.default.METHOD.SET, key, valueWithoutNestedNullValues);
         return updatePromise;
@@ -220,6 +227,13 @@ function set(key, value, options) {
  * @param data object keyed by ONYXKEYS and the values to set
  */
 function multiSet(data) {
+    return multiSetInternal(data);
+}
+/**
+ * @param isFromUpdate - Whether this call originates from Onyx.update()
+ * When isFromUpdate = true (called from Onyx.update()), useOnyx hook subscribers are batched to escape excessive re-renders in components
+ */
+function multiSetInternal(data, isFromUpdate = false) {
     let newData = data;
     const skippableCollectionMemberIDs = OnyxUtils_1.default.getSkippableCollectionMemberIDs();
     if (skippableCollectionMemberIDs.size) {
@@ -248,10 +262,10 @@ function multiSet(data) {
         }
         // Update cache and optimistically inform subscribers on the next tick
         OnyxCache_1.default.set(key, value);
-        return OnyxUtils_1.default.scheduleSubscriberUpdate(key, value, prevValue);
+        return OnyxUtils_1.default.scheduleSubscriberUpdate(key, value, prevValue, undefined, isFromUpdate);
     });
     return storage_1.default.multiSet(keyValuePairsToSet)
-        .catch((error) => OnyxUtils_1.default.evictStorageAndRetry(error, multiSet, newData))
+        .catch((error) => OnyxUtils_1.default.evictStorageAndRetry(error, multiSetInternal, newData, isFromUpdate))
         .then(() => {
         OnyxUtils_1.default.sendActionToDevTools(OnyxUtils_1.default.METHOD.MULTI_SET, undefined, newData);
         return Promise.all(updatePromises);
@@ -275,6 +289,13 @@ function multiSet(data) {
  * Onyx.merge(ONYXKEYS.POLICY, {name: 'My Workspace'}); // -> {id: 1, name: 'My Workspace'}
  */
 function merge(key, changes) {
+    return mergeInternal(key, changes);
+}
+/**
+ * @param isFromUpdate - Whether this call originates from Onyx.update()
+ * When isFromUpdate = true (called from Onyx.update()), useOnyx hook subscribers are batched to escape excessive re-renders in components
+ */
+function mergeInternal(key, changes, isFromUpdate = false) {
     const skippableCollectionMemberIDs = OnyxUtils_1.default.getSkippableCollectionMemberIDs();
     if (skippableCollectionMemberIDs.size) {
         try {
@@ -329,7 +350,7 @@ function merge(key, changes) {
                 OnyxUtils_1.default.logKeyRemoved(OnyxUtils_1.default.METHOD.MERGE, key);
                 return Promise.resolve();
             }
-            return OnyxMerge_1.default.applyMerge(key, existingValue, validChanges).then(({ mergedValue, updatePromise }) => {
+            return OnyxMerge_1.default.applyMerge(key, existingValue, validChanges, isFromUpdate).then(({ mergedValue, updatePromise }) => {
                 OnyxUtils_1.default.sendActionToDevTools(OnyxUtils_1.default.METHOD.MERGE, key, changes, mergedValue);
                 return updatePromise;
             });
@@ -355,7 +376,14 @@ function merge(key, changes) {
  * @param collection Object collection keyed by individual collection member keys and values
  */
 function mergeCollection(collectionKey, collection) {
-    return OnyxUtils_1.default.mergeCollectionWithPatches(collectionKey, collection);
+    return mergeCollectionInternal(collectionKey, collection);
+}
+/**
+ * @param isFromUpdate - Whether this call originates from Onyx.update()
+ * When isFromUpdate = true (called from Onyx.update()), useOnyx hook subscribers are batched to escape excessive re-renders in components
+ */
+function mergeCollectionInternal(collectionKey, collection, isFromUpdate = false) {
+    return OnyxUtils_1.default.mergeCollectionWithPatches(collectionKey, collection, undefined, isFromUpdate);
 }
 /**
  * Clear out all the data in the store
@@ -435,10 +463,10 @@ function clear(keysToPreserve = []) {
         const updatePromises = [];
         // Notify the subscribers for each key/value group so they can receive the new values
         Object.entries(keyValuesToResetIndividually).forEach(([key, value]) => {
-            updatePromises.push(OnyxUtils_1.default.scheduleSubscriberUpdate(key, value, OnyxCache_1.default.get(key, false)));
+            updatePromises.push(OnyxUtils_1.default.scheduleSubscriberUpdate(key, value, OnyxCache_1.default.get(key, false), undefined, false));
         });
         Object.entries(keyValuesToResetAsCollection).forEach(([key, value]) => {
-            updatePromises.push(OnyxUtils_1.default.scheduleNotifyCollectionSubscribers(key, value));
+            updatePromises.push(OnyxUtils_1.default.scheduleNotifyCollectionSubscribers(key, value, undefined, false));
         });
         const defaultKeyValuePairs = Object.entries(Object.keys(defaultKeyStates)
             .filter((key) => !keysToPreserve.includes(key))
@@ -522,7 +550,7 @@ function update(data) {
                     collectionKeys.forEach((collectionKey) => enqueueMergeOperation(collectionKey, mergedCollection[collectionKey]));
                 }
             },
-            [OnyxUtils_1.default.METHOD.SET_COLLECTION]: (k, v) => promises.push(() => setCollection(k, v)),
+            [OnyxUtils_1.default.METHOD.SET_COLLECTION]: (k, v) => promises.push(() => setCollectionInternal(k, v, true)),
             [OnyxUtils_1.default.METHOD.MULTI_SET]: (k, v) => Object.entries(v).forEach(([entryKey, entryValue]) => enqueueSetOperation(entryKey, entryValue)),
             [OnyxUtils_1.default.METHOD.CLEAR]: () => {
                 clearPromise = clear();
@@ -564,23 +592,23 @@ function update(data) {
             set: {},
         });
         if (!utils_1.default.isEmptyObject(batchedCollectionUpdates.merge)) {
-            promises.push(() => OnyxUtils_1.default.mergeCollectionWithPatches(collectionKey, batchedCollectionUpdates.merge, batchedCollectionUpdates.mergeReplaceNullPatches));
+            promises.push(() => OnyxUtils_1.default.mergeCollectionWithPatches(collectionKey, batchedCollectionUpdates.merge, batchedCollectionUpdates.mergeReplaceNullPatches, true));
         }
         if (!utils_1.default.isEmptyObject(batchedCollectionUpdates.set)) {
-            promises.push(() => multiSet(batchedCollectionUpdates.set));
+            promises.push(() => multiSetInternal(batchedCollectionUpdates.set, true));
         }
     });
     Object.entries(updateQueue).forEach(([key, operations]) => {
         if (operations[0] === null) {
             const batchedChanges = OnyxUtils_1.default.mergeChanges(operations).result;
-            promises.push(() => set(key, batchedChanges));
+            promises.push(() => setInternal(key, batchedChanges, undefined, true));
             return;
         }
         operations.forEach((operation) => {
-            promises.push(() => merge(key, operation));
+            promises.push(() => mergeInternal(key, operation, true));
         });
     });
-    const snapshotPromises = OnyxUtils_1.default.updateSnapshots(data, merge);
+    const snapshotPromises = OnyxUtils_1.default.updateSnapshots(data, (key, changes) => mergeInternal(key, changes, true));
     // We need to run the snapshot updates before the other updates so the snapshot data can be updated before the loading state in the snapshot
     const finalPromises = snapshotPromises.concat(promises);
     return clearPromise.then(() => Promise.all(finalPromises.map((p) => p()))).then(() => undefined);
@@ -599,6 +627,13 @@ function update(data) {
  * @param collection Object collection keyed by individual collection member keys and values
  */
 function setCollection(collectionKey, collection) {
+    return setCollectionInternal(collectionKey, collection);
+}
+/**
+ * @param isFromUpdate - Whether this call originates from Onyx.update()
+ * When isFromUpdate = true (called from Onyx.update()), useOnyx hook subscribers are batched to escape excessive re-renders in components
+ */
+function setCollectionInternal(collectionKey, collection, isFromUpdate = false) {
     let resultCollection = collection;
     let resultCollectionKeys = Object.keys(resultCollection);
     // Confirm all the collection keys belong to the same parent
@@ -638,9 +673,9 @@ function setCollection(collectionKey, collection) {
         const keyValuePairs = OnyxUtils_1.default.prepareKeyValuePairsForStorage(mutableCollection, true);
         const previousCollection = OnyxUtils_1.default.getCachedCollection(collectionKey);
         keyValuePairs.forEach(([key, value]) => OnyxCache_1.default.set(key, value));
-        const updatePromise = OnyxUtils_1.default.scheduleNotifyCollectionSubscribers(collectionKey, mutableCollection, previousCollection);
+        const updatePromise = OnyxUtils_1.default.scheduleNotifyCollectionSubscribers(collectionKey, mutableCollection, previousCollection, isFromUpdate);
         return storage_1.default.multiSet(keyValuePairs)
-            .catch((error) => OnyxUtils_1.default.evictStorageAndRetry(error, setCollection, collectionKey, collection))
+            .catch((error) => OnyxUtils_1.default.evictStorageAndRetry(error, setCollectionInternal, collectionKey, collection, isFromUpdate))
             .then(() => {
             OnyxUtils_1.default.sendActionToDevTools(OnyxUtils_1.default.METHOD.SET_COLLECTION, undefined, mutableCollection);
             return updatePromise;

package/dist/OnyxCache.d.ts

@@ -19,8 +19,8 @@ declare class OnyxCache {
     private recentKeys;
     /** A map of cached values */
     private storageMap;
-    /** Index mapping collection keys to their member keys for O(1) lookup */
-    private collectionIndex;
+    /** Cache of complete collection data objects for O(1) retrieval */
+    private collectionData;
     /**
      * Captured pending tasks for already running storage methods
      * Using a map yields better performance on operations such a delete
@@ -165,10 +165,6 @@ declare class OnyxCache {
      * Get all data for a collection key
      */
     getCollectionData(collectionKey: OnyxKey): Record<OnyxKey, OnyxValue<OnyxKey>> | undefined;
-    /**
-     * Get all member keys for a collection key
-     */
-    getCollectionMemberKeys(collectionKey: OnyxKey): Set<OnyxKey> | undefined;
 }
 declare const instance: OnyxCache;
 export default instance;

package/dist/OnyxCache.js

@@ -68,10 +68,10 @@ class OnyxCache {
         this.nullishStorageKeys = new Set();
         this.recentKeys = new Set();
         this.storageMap = {};
-        this.collectionIndex = {};
+        this.collectionData = {};
         this.pendingPromises = new Map();
         // bind all public methods to prevent problems with `this`
-        (0, bindAll_1.default)(this, 'getAllKeys', 'get', 'hasCacheForKey', 'addKey', 'addNullishStorageKey', 'hasNullishStorageKey', 'clearNullishStorageKeys', 'set', 'drop', 'merge', 'hasPendingTask', 'getTaskPromise', 'captureTask', 'addToAccessedKeys', 'removeLeastRecentlyUsedKeys', 'setRecentKeysLimit', 'setAllKeys', 'setEvictionAllowList', 'getEvictionBlocklist', 'isEvictableKey', 'removeLastAccessedKey', 'addLastAccessedKey', 'addEvictableKeysToRecentlyAccessedList', 'getKeyForEviction', 'setCollectionKeys', 'isCollectionKey', 'getCollectionKey', 'getCollectionData', 'getCollectionMemberKeys');
+        (0, bindAll_1.default)(this, 'getAllKeys', 'get', 'hasCacheForKey', 'addKey', 'addNullishStorageKey', 'hasNullishStorageKey', 'clearNullishStorageKeys', 'set', 'drop', 'merge', 'hasPendingTask', 'getTaskPromise', 'captureTask', 'addToAccessedKeys', 'removeLeastRecentlyUsedKeys', 'setRecentKeysLimit', 'setAllKeys', 'setEvictionAllowList', 'getEvictionBlocklist', 'isEvictableKey', 'removeLastAccessedKey', 'addLastAccessedKey', 'addEvictableKeysToRecentlyAccessedList', 'getKeyForEviction', 'setCollectionKeys', 'isCollectionKey', 'getCollectionKey', 'getCollectionData');
     }
     /** Get all the storage keys */
     getAllKeys() {
@@ -136,33 +136,33 @@ class OnyxCache {
         const collectionKey = this.getCollectionKey(key);
         if (value === null || value === undefined) {
             delete this.storageMap[key];
-            // Remove from collection index if it's a collection member
-            if (collectionKey && this.getCollectionMemberKeys(collectionKey)) {
-                this.collectionIndex[collectionKey].delete(key);
+            // Remove from collection data cache if it's a collection member
+            if (collectionKey && this.collectionData[collectionKey]) {
+                delete this.collectionData[collectionKey][key];
             }
             return undefined;
         }
         this.storageMap[key] = value;
-        // Update collection index if this is a collection member
+        // Update collection data cache if this is a collection member
         if (collectionKey) {
-            if (!this.getCollectionMemberKeys(collectionKey)) {
-                this.collectionIndex[collectionKey] = new Set();
+            if (!this.collectionData[collectionKey]) {
+                this.collectionData[collectionKey] = {};
             }
-            this.collectionIndex[collectionKey].add(key);
+            this.collectionData[collectionKey][key] = value;
         }
         return value;
     }
     /** Forget the cached value for the given key */
     drop(key) {
         delete this.storageMap[key];
-        // Update collection index if this is a collection member
+        // Remove from collection data cache if this is a collection member
         const collectionKey = this.getCollectionKey(key);
-        if (collectionKey && this.getCollectionMemberKeys(collectionKey)) {
-            this.collectionIndex[collectionKey].delete(key);
+        if (collectionKey && this.collectionData[collectionKey]) {
+            delete this.collectionData[collectionKey][key];
         }
-        // If this is a collection key, clear its index
+        // If this is a collection key, clear its data
         if (this.isCollectionKey(key)) {
-            delete this.collectionIndex[key];
+            delete this.collectionData[key];
         }
         this.storageKeys.delete(key);
         this.recentKeys.delete(key);
@@ -185,19 +185,19 @@ class OnyxCache {
             const collectionKey = this.getCollectionKey(key);
             if (value === null || value === undefined) {
                 this.addNullishStorageKey(key);
-                // Remove from collection index if it's a collection member
-                if (collectionKey && this.getCollectionMemberKeys(collectionKey)) {
-                    this.collectionIndex[collectionKey].delete(key);
+                // Remove from collection data cache if it's a collection member
+                if (collectionKey && this.collectionData[collectionKey]) {
+                    delete this.collectionData[collectionKey][key];
                 }
             }
             else {
                 this.nullishStorageKeys.delete(key);
-                // Update collection index if this is a collection member
+                // Update collection data cache if this is a collection member
                 if (collectionKey) {
-                    if (!this.getCollectionMemberKeys(collectionKey)) {
-                        this.collectionIndex[collectionKey] = new Set();
+                    if (!this.collectionData[collectionKey]) {
+                        this.collectionData[collectionKey] = {};
                     }
-                    this.collectionIndex[collectionKey].add(key);
+                    this.collectionData[collectionKey][key] = this.storageMap[key];
                 }
             }
         });
@@ -257,10 +257,10 @@ class OnyxCache {
         }
         for (const key of keysToRemove) {
             delete this.storageMap[key];
-            // Update collection index if this is a collection member
+            // Remove from collection data cache if this is a collection member
             const collectionKey = this.getCollectionKey(key);
-            if (collectionKey && this.getCollectionMemberKeys(collectionKey)) {
-                this.collectionIndex[collectionKey].delete(key);
+            if (collectionKey && this.collectionData[collectionKey]) {
+                delete this.collectionData[collectionKey][key];
             }
             this.recentKeys.delete(key);
         }
@@ -358,12 +358,12 @@ class OnyxCache {
      */
     setCollectionKeys(collectionKeys) {
         this.collectionKeys = collectionKeys;
-        // Initialize collection indexes for existing collection keys
+        // Initialize collection data for existing collection keys
         collectionKeys.forEach((collectionKey) => {
-            if (this.getCollectionMemberKeys(collectionKey)) {
+            if (this.collectionData[collectionKey]) {
                 return;
             }
-            this.collectionIndex[collectionKey] = new Set();
+            this.collectionData[collectionKey] = {};
         });
     }
     /**
@@ -387,24 +387,12 @@ class OnyxCache {
      * Get all data for a collection key
      */
     getCollectionData(collectionKey) {
-        const memberKeys = this.getCollectionMemberKeys(collectionKey);
-        if (!memberKeys || memberKeys.size === 0) {
+        const cachedCollection = this.collectionData[collectionKey];
+        if (!cachedCollection || Object.keys(cachedCollection).length === 0) {
             return undefined;
         }
-        const collectionData = {};
-        memberKeys.forEach((memberKey) => {
-            const value = this.storageMap[memberKey];
-            if (value !== undefined) {
-                collectionData[memberKey] = value;
-            }
-        });
-        return collectionData;
-    }
-    /**
-     * Get all member keys for a collection key
-     */
-    getCollectionMemberKeys(collectionKey) {
-        return this.collectionIndex[collectionKey];
+        // Return a shallow copy to ensure React detects changes when items are added/removed
+        return Object.assign({}, cachedCollection);
     }
 }
 const instance = new OnyxCache();

package/dist/OnyxMerge/index.js

@@ -6,14 +6,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const OnyxCache_1 = __importDefault(require("../OnyxCache"));
 const OnyxUtils_1 = __importDefault(require("../OnyxUtils"));
 const storage_1 = __importDefault(require("../storage"));
-const applyMerge = (key, existingValue, validChanges) => {
+const applyMerge = (key, existingValue, validChanges, isFromUpdate = false) => {
     const { result: mergedValue } = OnyxUtils_1.default.mergeChanges(validChanges, existingValue);
     // In cache, we don't want to remove the key if it's null to improve performance and speed up the next merge.
     const hasChanged = OnyxCache_1.default.hasValueChanged(key, mergedValue);
     // Logging properties only since values could be sensitive things we don't want to log.
     OnyxUtils_1.default.logKeyChanged(OnyxUtils_1.default.METHOD.MERGE, key, mergedValue, hasChanged);
     // This approach prioritizes fast UI changes without waiting for data to be stored in device storage.
-    const updatePromise = OnyxUtils_1.default.broadcastUpdate(key, mergedValue, hasChanged);
+    const updatePromise = OnyxUtils_1.default.broadcastUpdate(key, mergedValue, hasChanged, isFromUpdate);
     // If the value has not changed, calling Storage.setItem() would be redundant and a waste of performance, so return early instead.
     if (!hasChanged) {
         return Promise.resolve({ mergedValue, updatePromise });

package/dist/OnyxMerge/index.native.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const OnyxUtils_1 = __importDefault(require("../OnyxUtils"));
 const OnyxCache_1 = __importDefault(require("../OnyxCache"));
 const storage_1 = __importDefault(require("../storage"));
-const applyMerge = (key, existingValue, validChanges) => {
+const applyMerge = (key, existingValue, validChanges, isFromUpdate = false) => {
     // If any of the changes is null, we need to discard the existing value.
     const baseValue = validChanges.includes(null) ? undefined : existingValue;
     // We first batch the changes into a single change with object removal marks,
@@ -19,7 +19,7 @@ const applyMerge = (key, existingValue, validChanges) => {
     // Logging properties only since values could be sensitive things we don't want to log.
     OnyxUtils_1.default.logKeyChanged(OnyxUtils_1.default.METHOD.MERGE, key, mergedValue, hasChanged);
     // This approach prioritizes fast UI changes without waiting for data to be stored in device storage.
-    const updatePromise = OnyxUtils_1.default.broadcastUpdate(key, mergedValue, hasChanged);
+    const updatePromise = OnyxUtils_1.default.broadcastUpdate(key, mergedValue, hasChanged, isFromUpdate);
     // If the value has not changed, calling Storage.setItem() would be redundant and a waste of performance, so return early instead.
     if (!hasChanged) {
         return Promise.resolve({ mergedValue, updatePromise });

package/dist/OnyxMerge/types.d.ts

@@ -3,5 +3,5 @@ type ApplyMergeResult<TValue> = {
     mergedValue: TValue;
     updatePromise: Promise<void>;
 };
-type ApplyMerge = <TKey extends OnyxKey, TValue extends OnyxInput<OnyxKey> | undefined, TChange extends OnyxInput<OnyxKey> | null>(key: TKey, existingValue: TValue, validChanges: TChange[]) => Promise<ApplyMergeResult<TChange>>;
+type ApplyMerge = <TKey extends OnyxKey, TValue extends OnyxInput<OnyxKey> | undefined, TChange extends OnyxInput<OnyxKey> | null>(key: TKey, existingValue: TValue, validChanges: TChange[], isFromUpdate?: boolean) => Promise<ApplyMergeResult<TChange>>;
 export type { ApplyMerge, ApplyMergeResult };

package/dist/OnyxUtils.d.ts

@@ -143,14 +143,14 @@ declare function getCachedCollection<TKey extends CollectionKeyBase>(collectionK
 /**
  * When a collection of keys change, search for any callbacks matching the collection key and trigger those callbacks
  */
-declare function keysChanged<TKey extends CollectionKeyBase>(collectionKey: TKey, partialCollection: OnyxCollection<KeyValueMapping[TKey]>, partialPreviousCollection: OnyxCollection<KeyValueMapping[TKey]> | undefined, notifyConnectSubscribers?: boolean, notifyWithOnyxSubscribers?: boolean): void;
+declare function keysChanged<TKey extends CollectionKeyBase>(collectionKey: TKey, partialCollection: OnyxCollection<KeyValueMapping[TKey]>, partialPreviousCollection: OnyxCollection<KeyValueMapping[TKey]> | undefined, notifyConnectSubscribers?: boolean, notifyWithOnyxSubscribers?: boolean, notifyUseOnyxHookSubscribers?: boolean): void;
 /**
  * When a key change happens, search for any callbacks matching the key or collection key and trigger those callbacks
  *
  * @example
  * keyChanged(key, value, subscriber => subscriber.initWithStoredValues === false)
  */
-declare function keyChanged<TKey extends OnyxKey>(key: TKey, value: OnyxValue<TKey>, previousValue: OnyxValue<TKey>, canUpdateSubscriber?: (subscriber?: Mapping<OnyxKey>) => boolean, notifyConnectSubscribers?: boolean, notifyWithOnyxSubscribers?: boolean): void;
+declare function keyChanged<TKey extends OnyxKey>(key: TKey, value: OnyxValue<TKey>, previousValue: OnyxValue<TKey>, canUpdateSubscriber?: (subscriber?: Mapping<OnyxKey>) => boolean, notifyConnectSubscribers?: boolean, notifyWithOnyxSubscribers?: boolean, notifyUseOnyxHookSubscribers?: boolean): void;
 /**
  * Sends the data obtained from the keys to the connection. It either:
  *     - sets state on the withOnyxInstances
@@ -172,13 +172,13 @@ declare function getCollectionDataAndSendAsObject<TKey extends OnyxKey>(matching
  * @example
  * scheduleSubscriberUpdate(key, value, subscriber => subscriber.initWithStoredValues === false)
  */
-declare function scheduleSubscriberUpdate<TKey extends OnyxKey>(key: TKey, value: OnyxValue<TKey>, previousValue: OnyxValue<TKey>, canUpdateSubscriber?: (subscriber?: Mapping<OnyxKey>) => boolean): Promise<void>;
+declare function scheduleSubscriberUpdate<TKey extends OnyxKey>(key: TKey, value: OnyxValue<TKey>, previousValue: OnyxValue<TKey>, canUpdateSubscriber?: (subscriber?: Mapping<OnyxKey>) => boolean, isFromUpdate?: boolean): Promise<void>;
 /**
  * This method is similar to notifySubscribersOnNextTick but it is built for working specifically with collections
  * so that keysChanged() is triggered for the collection and not keyChanged(). If this was not done, then the
  * subscriber callbacks receive the data in a different format than they normally expect and it breaks code.
  */
-declare function scheduleNotifyCollectionSubscribers<TKey extends OnyxKey>(key: TKey, value: OnyxCollection<KeyValueMapping[TKey]>, previousValue?: OnyxCollection<KeyValueMapping[TKey]>): Promise<void>;
+declare function scheduleNotifyCollectionSubscribers<TKey extends OnyxKey>(key: TKey, value: OnyxCollection<KeyValueMapping[TKey]>, previousValue?: OnyxCollection<KeyValueMapping[TKey]>, isFromUpdate?: boolean): Promise<void>;
 /**
  * Remove a key from Onyx and update the subscribers
  */
@@ -193,7 +193,7 @@ declare function evictStorageAndRetry<TMethod extends typeof Onyx.set | typeof O
 /**
  * Notifies subscribers and writes current value to cache
  */
-declare function broadcastUpdate<TKey extends OnyxKey>(key: TKey, value: OnyxValue<TKey>, hasChanged?: boolean): Promise<void>;
+declare function broadcastUpdate<TKey extends OnyxKey>(key: TKey, value: OnyxValue<TKey>, hasChanged?: boolean, isFromUpdate?: boolean): Promise<void>;
 declare function hasPendingMergeForKey(key: OnyxKey): boolean;
 /**
  * Storage expects array like: [["@MyApp_user", value_1], ["@MyApp_key", value_2]]
@@ -254,7 +254,7 @@ declare function updateSnapshots(data: OnyxUpdate[], mergeFn: typeof Onyx.merge)
  * @param mergeReplaceNullPatches Record where the key is a collection member key and the value is a list of
  * tuples that we'll use to replace the nested objects of that collection member record with something else.
  */
-declare function mergeCollectionWithPatches<TKey extends CollectionKeyBase, TMap>(collectionKey: TKey, collection: OnyxMergeCollectionInput<TKey, TMap>, mergeReplaceNullPatches?: MultiMergeReplaceNullPatches): Promise<void>;
+declare function mergeCollectionWithPatches<TKey extends CollectionKeyBase, TMap>(collectionKey: TKey, collection: OnyxMergeCollectionInput<TKey, TMap>, mergeReplaceNullPatches?: MultiMergeReplaceNullPatches, isFromUpdate?: boolean): Promise<void>;
 declare function logKeyChanged(onyxMethod: Extract<OnyxMethod, 'set' | 'merge'>, key: OnyxKey, value: unknown, hasChanged: boolean): void;
 declare function logKeyRemoved(onyxMethod: Extract<OnyxMethod, 'set' | 'merge'>, key: OnyxKey): void;
 /**

package/dist/OnyxUtils.js

@@ -440,25 +440,16 @@ function tryGetCachedValue(key, mapping) {
     let val = OnyxCache_1.default.get(key);
     if (isCollectionKey(key)) {
         const collectionData = OnyxCache_1.default.getCollectionData(key);
-        const allCacheKeys = OnyxCache_1.default.getAllKeys();
-        if (collectionData !== undefined && allCacheKeys.size > 0) {
+        if (collectionData !== undefined) {
             val = collectionData;
         }
         else {
-            // Fallback to original logic
-            // It is possible we haven't loaded all keys yet so we do not know if the
-            // collection actually exists.
-            if (allCacheKeys.size === 0) {
+            // If we haven't loaded all keys yet, we can't determine if the collection exists
+            if (OnyxCache_1.default.getAllKeys().size === 0) {
                 return;
             }
-            const values = {};
-            allCacheKeys.forEach((cacheKey) => {
-                if (!cacheKey.startsWith(key)) {
-                    return;
-                }
-                values[cacheKey] = OnyxCache_1.default.get(cacheKey);
-            });
-            val = values;
+            // Set an empty collection object for collections that exist but have no data
+            val = {};
         }
     }
     if (mapping === null || mapping === void 0 ? void 0 : mapping.selector) {
@@ -512,7 +503,7 @@ function getCachedCollection(collectionKey, collectionMemberKeys) {
 /**
  * When a collection of keys change, search for any callbacks matching the collection key and trigger those callbacks
  */
-function keysChanged(collectionKey, partialCollection, partialPreviousCollection, notifyConnectSubscribers = true, notifyWithOnyxSubscribers = true) {
+function keysChanged(collectionKey, partialCollection, partialPreviousCollection, notifyConnectSubscribers = true, notifyWithOnyxSubscribers = true, notifyUseOnyxHookSubscribers = true) {
     // We prepare the "cached collection" which is the entire collection + the new partial data that
     // was merged in via mergeCollection().
     const cachedCollection = getCachedCollection(collectionKey);
@@ -540,7 +531,8 @@ function keysChanged(collectionKey, partialCollection, partialPreviousCollection
         const isSubscribedToCollectionMemberKey = isCollectionMemberKey(collectionKey, subscriber.key);
         // Regular Onyx.connect() subscriber found.
         if (typeof subscriber.callback === 'function') {
-            if (!notifyConnectSubscribers) {
+            // Check if it's a useOnyx or a regular Onyx.connect() subscriber
+            if ((subscriber.isUseOnyxSubscriber && !notifyUseOnyxHookSubscribers) || (!subscriber.isUseOnyxSubscriber && !notifyConnectSubscribers)) {
                 continue;
             }
             // If they are subscribed to the collection key and using waitForCollectionCallback then we'll
@@ -670,7 +662,7 @@ function keysChanged(collectionKey, partialCollection, partialPreviousCollection
  * @example
  * keyChanged(key, value, subscriber => subscriber.initWithStoredValues === false)
  */
-function keyChanged(key, value, previousValue, canUpdateSubscriber = () => true, notifyConnectSubscribers = true, notifyWithOnyxSubscribers = true) {
+function keyChanged(key, value, previousValue, canUpdateSubscriber = () => true, notifyConnectSubscribers = true, notifyWithOnyxSubscribers = true, notifyUseOnyxHookSubscribers = true) {
     var _a, _b;
     // Add or remove this key from the recentlyAccessedKeys lists
     if (value !== null) {
@@ -709,7 +701,8 @@ function keyChanged(key, value, previousValue, canUpdateSubscriber = () => true,
         }
         // Subscriber is a regular call to connect() and provided a callback
         if (typeof subscriber.callback === 'function') {
-            if (!notifyConnectSubscribers) {
+            // Check if it's a useOnyx or a regular Onyx.connect() subscriber
+            if ((subscriber.isUseOnyxSubscriber && !notifyUseOnyxHookSubscribers) || (!subscriber.isUseOnyxSubscriber && !notifyConnectSubscribers)) {
                 continue;
             }
             if (lastConnectionCallbackData.has(subscriber.subscriptionID) && lastConnectionCallbackData.get(subscriber.subscriptionID) === value) {
@@ -888,9 +881,9 @@ function getCollectionDataAndSendAsObject(matchingKeys, mapping) {
  * @example
  * scheduleSubscriberUpdate(key, value, subscriber => subscriber.initWithStoredValues === false)
  */
-function scheduleSubscriberUpdate(key, value, previousValue, canUpdateSubscriber = () => true) {
-    const promise = Promise.resolve().then(() => keyChanged(key, value, previousValue, canUpdateSubscriber, true, false));
-    batchUpdates(() => keyChanged(key, value, previousValue, canUpdateSubscriber, false, true));
+function scheduleSubscriberUpdate(key, value, previousValue, canUpdateSubscriber = () => true, isFromUpdate = false) {
+    const promise = Promise.resolve().then(() => keyChanged(key, value, previousValue, canUpdateSubscriber, true, false, !isFromUpdate));
+    batchUpdates(() => keyChanged(key, value, previousValue, canUpdateSubscriber, false, true, isFromUpdate));
     return Promise.all([maybeFlushBatchUpdates(), promise]).then(() => undefined);
 }
 /**
@@ -898,9 +891,9 @@ function scheduleSubscriberUpdate(key, value, previousValue, canUpdateSubscriber
  * so that keysChanged() is triggered for the collection and not keyChanged(). If this was not done, then the
  * subscriber callbacks receive the data in a different format than they normally expect and it breaks code.
  */
-function scheduleNotifyCollectionSubscribers(key, value, previousValue) {
-    const promise = Promise.resolve().then(() => keysChanged(key, value, previousValue, true, false));
-    batchUpdates(() => keysChanged(key, value, previousValue, false, true));
+function scheduleNotifyCollectionSubscribers(key, value, previousValue, isFromUpdate = false) {
+    const promise = Promise.resolve().then(() => keysChanged(key, value, previousValue, true, false, !isFromUpdate));
+    batchUpdates(() => keysChanged(key, value, previousValue, false, true, isFromUpdate));
     return Promise.all([maybeFlushBatchUpdates(), promise]).then(() => undefined);
 }
 /**
@@ -950,7 +943,7 @@ function evictStorageAndRetry(error, onyxMethod, ...args) {
 /**
  * Notifies subscribers and writes current value to cache
  */
-function broadcastUpdate(key, value, hasChanged) {
+function broadcastUpdate(key, value, hasChanged, isFromUpdate = false) {
     const prevValue = OnyxCache_1.default.get(key, false);
     // Update subscribers if the cached value has changed, or when the subscriber specifically requires
     // all updates regardless of value changes (indicated by initWithStoredValues set to false).
@@ -960,7 +953,7 @@ function broadcastUpdate(key, value, hasChanged) {
     else {
         OnyxCache_1.default.addToAccessedKeys(key);
     }
-    return scheduleSubscriberUpdate(key, value, prevValue, (subscriber) => hasChanged || (subscriber === null || subscriber === void 0 ? void 0 : subscriber.initWithStoredValues) === false).then(() => undefined);
+    return scheduleSubscriberUpdate(key, value, prevValue, (subscriber) => hasChanged || (subscriber === null || subscriber === void 0 ? void 0 : subscriber.initWithStoredValues) === false, isFromUpdate).then(() => undefined);
 }
 function hasPendingMergeForKey(key) {
     return !!mergeQueue[key];
@@ -1238,7 +1231,7 @@ function updateSnapshots(data, mergeFn) {
  * @param mergeReplaceNullPatches Record where the key is a collection member key and the value is a list of
  * tuples that we'll use to replace the nested objects of that collection member record with something else.
  */
-function mergeCollectionWithPatches(collectionKey, collection, mergeReplaceNullPatches) {
+function mergeCollectionWithPatches(collectionKey, collection, mergeReplaceNullPatches, isFromUpdate = false) {
     if (!isValidNonEmptyCollectionForMerge(collection)) {
         Logger.logInfo('mergeCollection() called with invalid or empty value. Skipping this update.');
         return Promise.resolve();
@@ -1320,7 +1313,7 @@ function mergeCollectionWithPatches(collectionKey, collection, mergeReplaceNullP
         // and update all subscribers
         const promiseUpdate = previousCollectionPromise.then((previousCollection) => {
             OnyxCache_1.default.merge(finalMergedCollection);
-            return scheduleNotifyCollectionSubscribers(collectionKey, finalMergedCollection, previousCollection);
+            return scheduleNotifyCollectionSubscribers(collectionKey, finalMergedCollection, previousCollection, isFromUpdate);
         });
         return Promise.all(promises)
             .catch((error) => evictStorageAndRetry(error, mergeCollectionWithPatches, collectionKey, resultCollection))

package/dist/types.d.ts

@@ -235,6 +235,8 @@ type BaseConnectOptions = {
      * with the same connect configurations.
      */
     reuseConnection?: boolean;
+    /** Indicates whether this subscriber is created from the useOnyx hook. */
+    isUseOnyxSubscriber?: boolean;
 };
 /** Represents the callback function used in `Onyx.connect()` method with a regular key. */
 type DefaultConnectCallback<TKey extends OnyxKey> = (value: OnyxEntry<KeyValueMapping[TKey]>, key: TKey) => void;

package/dist/useOnyx.js

@@ -276,6 +276,7 @@ function useOnyx(key, options, dependencies = []) {
             initWithStoredValues: options === null || options === void 0 ? void 0 : options.initWithStoredValues,
             waitForCollectionCallback: OnyxUtils_1.default.isCollectionKey(key),
             reuseConnection: options === null || options === void 0 ? void 0 : options.reuseConnection,
+            isUseOnyxSubscriber: true,
         });
         checkEvictableKey();
         return () => {

package/package.json

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