react-native-onyx 2.0.139 → 2.0.141

package/dist/Onyx.js

@@ -155,13 +155,6 @@ 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)) {
@@ -207,13 +200,13 @@ function setInternal(key, value, options, isFromUpdate = false) {
     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, isFromUpdate);
+    const updatePromise = OnyxUtils_1.default.broadcastUpdate(key, valueWithoutNestedNullValues, hasChanged);
     // 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, setInternal, key, valueWithoutNestedNullValues, undefined, isFromUpdate))
+        .catch((error) => OnyxUtils_1.default.evictStorageAndRetry(error, set, key, valueWithoutNestedNullValues))
         .then(() => {
         OnyxUtils_1.default.sendActionToDevTools(OnyxUtils_1.default.METHOD.SET, key, valueWithoutNestedNullValues);
         return updatePromise;
@@ -227,13 +220,6 @@ function setInternal(key, value, options, isFromUpdate = false) {
  * @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) {
@@ -262,10 +248,10 @@ function multiSetInternal(data, isFromUpdate = false) {
         }
         // Update cache and optimistically inform subscribers on the next tick
         OnyxCache_1.default.set(key, value);
-        return OnyxUtils_1.default.scheduleSubscriberUpdate(key, value, prevValue, undefined, isFromUpdate);
+        return OnyxUtils_1.default.scheduleSubscriberUpdate(key, value, prevValue);
     });
     return storage_1.default.multiSet(keyValuePairsToSet)
-        .catch((error) => OnyxUtils_1.default.evictStorageAndRetry(error, multiSetInternal, newData, isFromUpdate))
+        .catch((error) => OnyxUtils_1.default.evictStorageAndRetry(error, multiSet, newData))
         .then(() => {
         OnyxUtils_1.default.sendActionToDevTools(OnyxUtils_1.default.METHOD.MULTI_SET, undefined, newData);
         return Promise.all(updatePromises);
@@ -289,13 +275,6 @@ function multiSetInternal(data, isFromUpdate = false) {
  * 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 {
@@ -350,7 +329,7 @@ function mergeInternal(key, changes, isFromUpdate = false) {
                 OnyxUtils_1.default.logKeyRemoved(OnyxUtils_1.default.METHOD.MERGE, key);
                 return Promise.resolve();
             }
-            return OnyxMerge_1.default.applyMerge(key, existingValue, validChanges, isFromUpdate).then(({ mergedValue, updatePromise }) => {
+            return OnyxMerge_1.default.applyMerge(key, existingValue, validChanges).then(({ mergedValue, updatePromise }) => {
                 OnyxUtils_1.default.sendActionToDevTools(OnyxUtils_1.default.METHOD.MERGE, key, changes, mergedValue);
                 return updatePromise;
             });
@@ -376,14 +355,7 @@ function mergeInternal(key, changes, isFromUpdate = false) {
  * @param collection Object collection keyed by individual collection member keys and values
  */
 function mergeCollection(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);
+    return OnyxUtils_1.default.mergeCollectionWithPatches(collectionKey, collection);
 }
 /**
  * Clear out all the data in the store
@@ -463,10 +435,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), undefined, false));
+            updatePromises.push(OnyxUtils_1.default.scheduleSubscriberUpdate(key, value, OnyxCache_1.default.get(key, false)));
         });
         Object.entries(keyValuesToResetAsCollection).forEach(([key, value]) => {
-            updatePromises.push(OnyxUtils_1.default.scheduleNotifyCollectionSubscribers(key, value, undefined, false));
+            updatePromises.push(OnyxUtils_1.default.scheduleNotifyCollectionSubscribers(key, value));
         });
         const defaultKeyValuePairs = Object.entries(Object.keys(defaultKeyStates)
             .filter((key) => !keysToPreserve.includes(key))
@@ -550,7 +522,7 @@ function update(data) {
                     collectionKeys.forEach((collectionKey) => enqueueMergeOperation(collectionKey, mergedCollection[collectionKey]));
                 }
             },
-            [OnyxUtils_1.default.METHOD.SET_COLLECTION]: (k, v) => promises.push(() => setCollectionInternal(k, v, true)),
+            [OnyxUtils_1.default.METHOD.SET_COLLECTION]: (k, v) => promises.push(() => setCollection(k, v)),
             [OnyxUtils_1.default.METHOD.MULTI_SET]: (k, v) => Object.entries(v).forEach(([entryKey, entryValue]) => enqueueSetOperation(entryKey, entryValue)),
             [OnyxUtils_1.default.METHOD.CLEAR]: () => {
                 clearPromise = clear();
@@ -592,23 +564,23 @@ function update(data) {
             set: {},
         });
         if (!utils_1.default.isEmptyObject(batchedCollectionUpdates.merge)) {
-            promises.push(() => OnyxUtils_1.default.mergeCollectionWithPatches(collectionKey, batchedCollectionUpdates.merge, batchedCollectionUpdates.mergeReplaceNullPatches, true));
+            promises.push(() => OnyxUtils_1.default.mergeCollectionWithPatches(collectionKey, batchedCollectionUpdates.merge, batchedCollectionUpdates.mergeReplaceNullPatches));
         }
         if (!utils_1.default.isEmptyObject(batchedCollectionUpdates.set)) {
-            promises.push(() => multiSetInternal(batchedCollectionUpdates.set, true));
+            promises.push(() => OnyxUtils_1.default.partialSetCollection(collectionKey, batchedCollectionUpdates.set));
         }
     });
     Object.entries(updateQueue).forEach(([key, operations]) => {
         if (operations[0] === null) {
             const batchedChanges = OnyxUtils_1.default.mergeChanges(operations).result;
-            promises.push(() => setInternal(key, batchedChanges, undefined, true));
+            promises.push(() => set(key, batchedChanges));
             return;
         }
         operations.forEach((operation) => {
-            promises.push(() => mergeInternal(key, operation, true));
+            promises.push(() => merge(key, operation));
         });
     });
-    const snapshotPromises = OnyxUtils_1.default.updateSnapshots(data, (key, changes) => mergeInternal(key, changes, true));
+    const snapshotPromises = OnyxUtils_1.default.updateSnapshots(data, merge);
     // 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);
@@ -627,13 +599,6 @@ 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
@@ -673,9 +638,9 @@ function setCollectionInternal(collectionKey, collection, isFromUpdate = false)
         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, isFromUpdate);
+        const updatePromise = OnyxUtils_1.default.scheduleNotifyCollectionSubscribers(collectionKey, mutableCollection, previousCollection);
         return storage_1.default.multiSet(keyValuePairs)
-            .catch((error) => OnyxUtils_1.default.evictStorageAndRetry(error, setCollectionInternal, collectionKey, collection, isFromUpdate))
+            .catch((error) => OnyxUtils_1.default.evictStorageAndRetry(error, setCollection, collectionKey, collection))
             .then(() => {
             OnyxUtils_1.default.sendActionToDevTools(OnyxUtils_1.default.METHOD.SET_COLLECTION, undefined, mutableCollection);
             return updatePromise;

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, isFromUpdate = false) => {
+const applyMerge = (key, existingValue, validChanges) => {
     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, isFromUpdate);
+    const updatePromise = OnyxUtils_1.default.broadcastUpdate(key, mergedValue, hasChanged);
     // 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, isFromUpdate = false) => {
+const applyMerge = (key, existingValue, validChanges) => {
     // 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, isFromUpdate = false) => {
     // 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, isFromUpdate);
+    const updatePromise = OnyxUtils_1.default.broadcastUpdate(key, mergedValue, hasChanged);
     // 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[], isFromUpdate?: boolean) => Promise<ApplyMergeResult<TChange>>;
+type ApplyMerge = <TKey extends OnyxKey, TValue extends OnyxInput<OnyxKey> | undefined, TChange extends OnyxInput<OnyxKey> | null>(key: TKey, existingValue: TValue, validChanges: TChange[]) => 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, notifyUseOnyxHookSubscribers?: boolean): void;
+declare function keysChanged<TKey extends CollectionKeyBase>(collectionKey: TKey, partialCollection: OnyxCollection<KeyValueMapping[TKey]>, partialPreviousCollection: OnyxCollection<KeyValueMapping[TKey]> | undefined, notifyConnectSubscribers?: boolean, notifyWithOnyxSubscribers?: 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, notifyUseOnyxHookSubscribers?: 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): 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, isFromUpdate?: boolean): Promise<void>;
+declare function scheduleSubscriberUpdate<TKey extends OnyxKey>(key: TKey, value: OnyxValue<TKey>, previousValue: OnyxValue<TKey>, canUpdateSubscriber?: (subscriber?: Mapping<OnyxKey>) => 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]>, isFromUpdate?: boolean): Promise<void>;
+declare function scheduleNotifyCollectionSubscribers<TKey extends OnyxKey>(key: TKey, value: OnyxCollection<KeyValueMapping[TKey]>, previousValue?: OnyxCollection<KeyValueMapping[TKey]>): 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, isFromUpdate?: boolean): Promise<void>;
+declare function broadcastUpdate<TKey extends OnyxKey>(key: TKey, value: OnyxValue<TKey>, hasChanged?: boolean): Promise<void>;
 declare function hasPendingMergeForKey(key: OnyxKey): boolean;
 /**
  * Storage expects array like: [["@MyApp_user", value_1], ["@MyApp_key", value_2]]
@@ -254,7 +254,15 @@ 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, isFromUpdate?: boolean): Promise<void>;
+declare function mergeCollectionWithPatches<TKey extends CollectionKeyBase, TMap>(collectionKey: TKey, collection: OnyxMergeCollectionInput<TKey, TMap>, mergeReplaceNullPatches?: MultiMergeReplaceNullPatches): Promise<void>;
+/**
+ * Sets keys in a collection by replacing all targeted collection members with new values.
+ * Any existing collection members not included in the new data will not be removed.
+ *
+ * @param collectionKey e.g. `ONYXKEYS.COLLECTION.REPORT`
+ * @param collection Object collection keyed by individual collection member keys and values
+ */
+declare function partialSetCollection<TKey extends CollectionKeyBase, TMap>(collectionKey: TKey, collection: OnyxMergeCollectionInput<TKey, TMap>): 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;
 /**
@@ -318,6 +326,7 @@ declare const OnyxUtils: {
     reduceCollectionWithSelector: typeof reduceCollectionWithSelector;
     updateSnapshots: typeof updateSnapshots;
     mergeCollectionWithPatches: typeof mergeCollectionWithPatches;
+    partialSetCollection: typeof partialSetCollection;
     logKeyChanged: typeof logKeyChanged;
     logKeyRemoved: typeof logKeyRemoved;
 };

package/dist/OnyxUtils.js

@@ -503,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, notifyUseOnyxHookSubscribers = true) {
+function keysChanged(collectionKey, partialCollection, partialPreviousCollection, notifyConnectSubscribers = true, notifyWithOnyxSubscribers = 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);
@@ -531,8 +531,7 @@ function keysChanged(collectionKey, partialCollection, partialPreviousCollection
         const isSubscribedToCollectionMemberKey = isCollectionMemberKey(collectionKey, subscriber.key);
         // Regular Onyx.connect() subscriber found.
         if (typeof subscriber.callback === 'function') {
-            // Check if it's a useOnyx or a regular Onyx.connect() subscriber
-            if ((subscriber.isUseOnyxSubscriber && !notifyUseOnyxHookSubscribers) || (!subscriber.isUseOnyxSubscriber && !notifyConnectSubscribers)) {
+            if (!notifyConnectSubscribers) {
                 continue;
             }
             // If they are subscribed to the collection key and using waitForCollectionCallback then we'll
@@ -662,7 +661,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, notifyUseOnyxHookSubscribers = true) {
+function keyChanged(key, value, previousValue, canUpdateSubscriber = () => true, notifyConnectSubscribers = true, notifyWithOnyxSubscribers = true) {
     var _a, _b;
     // Add or remove this key from the recentlyAccessedKeys lists
     if (value !== null) {
@@ -701,8 +700,7 @@ function keyChanged(key, value, previousValue, canUpdateSubscriber = () => true,
         }
         // Subscriber is a regular call to connect() and provided a callback
         if (typeof subscriber.callback === 'function') {
-            // Check if it's a useOnyx or a regular Onyx.connect() subscriber
-            if ((subscriber.isUseOnyxSubscriber && !notifyUseOnyxHookSubscribers) || (!subscriber.isUseOnyxSubscriber && !notifyConnectSubscribers)) {
+            if (!notifyConnectSubscribers) {
                 continue;
             }
             if (lastConnectionCallbackData.has(subscriber.subscriptionID) && lastConnectionCallbackData.get(subscriber.subscriptionID) === value) {
@@ -881,9 +879,9 @@ function getCollectionDataAndSendAsObject(matchingKeys, mapping) {
  * @example
  * scheduleSubscriberUpdate(key, value, subscriber => subscriber.initWithStoredValues === false)
  */
-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));
+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));
     return Promise.all([maybeFlushBatchUpdates(), promise]).then(() => undefined);
 }
 /**
@@ -891,9 +889,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, isFromUpdate = false) {
-    const promise = Promise.resolve().then(() => keysChanged(key, value, previousValue, true, false, !isFromUpdate));
-    batchUpdates(() => keysChanged(key, value, previousValue, false, true, isFromUpdate));
+function scheduleNotifyCollectionSubscribers(key, value, previousValue) {
+    const promise = Promise.resolve().then(() => keysChanged(key, value, previousValue, true, false));
+    batchUpdates(() => keysChanged(key, value, previousValue, false, true));
     return Promise.all([maybeFlushBatchUpdates(), promise]).then(() => undefined);
 }
 /**
@@ -943,7 +941,7 @@ function evictStorageAndRetry(error, onyxMethod, ...args) {
 /**
  * Notifies subscribers and writes current value to cache
  */
-function broadcastUpdate(key, value, hasChanged, isFromUpdate = false) {
+function broadcastUpdate(key, value, hasChanged) {
     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).
@@ -953,7 +951,7 @@ function broadcastUpdate(key, value, hasChanged, isFromUpdate = false) {
     else {
         OnyxCache_1.default.addToAccessedKeys(key);
     }
-    return scheduleSubscriberUpdate(key, value, prevValue, (subscriber) => hasChanged || (subscriber === null || subscriber === void 0 ? void 0 : subscriber.initWithStoredValues) === false, isFromUpdate).then(() => undefined);
+    return scheduleSubscriberUpdate(key, value, prevValue, (subscriber) => hasChanged || (subscriber === null || subscriber === void 0 ? void 0 : subscriber.initWithStoredValues) === false).then(() => undefined);
 }
 function hasPendingMergeForKey(key) {
     return !!mergeQueue[key];
@@ -1231,7 +1229,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, isFromUpdate = false) {
+function mergeCollectionWithPatches(collectionKey, collection, mergeReplaceNullPatches) {
     if (!isValidNonEmptyCollectionForMerge(collection)) {
         Logger.logInfo('mergeCollection() called with invalid or empty value. Skipping this update.');
         return Promise.resolve();
@@ -1313,7 +1311,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, isFromUpdate);
+            return scheduleNotifyCollectionSubscribers(collectionKey, finalMergedCollection, previousCollection);
         });
         return Promise.all(promises)
             .catch((error) => evictStorageAndRetry(error, mergeCollectionWithPatches, collectionKey, resultCollection))
@@ -1324,6 +1322,53 @@ function mergeCollectionWithPatches(collectionKey, collection, mergeReplaceNullP
     })
         .then(() => undefined);
 }
+/**
+ * Sets keys in a collection by replacing all targeted collection members with new values.
+ * Any existing collection members not included in the new data will not be removed.
+ *
+ * @param collectionKey e.g. `ONYXKEYS.COLLECTION.REPORT`
+ * @param collection Object collection keyed by individual collection member keys and values
+ */
+function partialSetCollection(collectionKey, collection) {
+    let resultCollection = collection;
+    let resultCollectionKeys = Object.keys(resultCollection);
+    // Confirm all the collection keys belong to the same parent
+    if (!doAllCollectionItemsBelongToSameParent(collectionKey, resultCollectionKeys)) {
+        Logger.logAlert(`setCollection called with keys that do not belong to the same parent ${collectionKey}. Skipping this update.`);
+        return Promise.resolve();
+    }
+    if (skippableCollectionMemberIDs.size) {
+        resultCollection = resultCollectionKeys.reduce((result, key) => {
+            try {
+                const [, collectionMemberID] = splitCollectionMemberKey(key, collectionKey);
+                // If the collection member key is a skippable one we set its value to null.
+                // eslint-disable-next-line no-param-reassign
+                result[key] = !skippableCollectionMemberIDs.has(collectionMemberID) ? resultCollection[key] : null;
+            }
+            catch (_a) {
+                // Something went wrong during split, so we assign the data to result anyway.
+                // eslint-disable-next-line no-param-reassign
+                result[key] = resultCollection[key];
+            }
+            return result;
+        }, {});
+    }
+    resultCollectionKeys = Object.keys(resultCollection);
+    return getAllKeys().then((persistedKeys) => {
+        const mutableCollection = Object.assign({}, resultCollection);
+        const existingKeys = resultCollectionKeys.filter((key) => persistedKeys.has(key));
+        const previousCollection = getCachedCollection(collectionKey, existingKeys);
+        const keyValuePairs = prepareKeyValuePairsForStorage(mutableCollection, true);
+        keyValuePairs.forEach(([key, value]) => OnyxCache_1.default.set(key, value));
+        const updatePromise = scheduleNotifyCollectionSubscribers(collectionKey, mutableCollection, previousCollection);
+        return storage_1.default.multiSet(keyValuePairs)
+            .catch((error) => evictStorageAndRetry(error, partialSetCollection, collectionKey, collection))
+            .then(() => {
+            sendActionToDevTools(METHOD.SET_COLLECTION, undefined, mutableCollection);
+            return updatePromise;
+        });
+    });
+}
 function logKeyChanged(onyxMethod, key, value, hasChanged) {
     Logger.logInfo(`${onyxMethod} called for key: ${key}${underscore_1.default.isObject(value) ? ` properties: ${underscore_1.default.keys(value).join(',')}` : ''} hasChanged: ${hasChanged}`);
 }
@@ -1391,6 +1436,7 @@ const OnyxUtils = {
     reduceCollectionWithSelector,
     updateSnapshots,
     mergeCollectionWithPatches,
+    partialSetCollection,
     logKeyChanged,
     logKeyRemoved,
 };

package/dist/types.d.ts

@@ -235,8 +235,6 @@ 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,7 +276,6 @@ 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.139",
+  "version": "2.0.141",
   "author": "Expensify, Inc.",
   "homepage": "https://expensify.com",
   "description": "State management for React Native",