react-native-onyx 3.0.44 → 3.0.46

package/dist/Onyx.js

@@ -240,9 +240,8 @@ 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).then(({ mergedValue }) => {
                     OnyxUtils_1.default.sendActionToDevTools(OnyxUtils_1.default.METHOD.MERGE, key, changes, mergedValue);
-                    return updatePromise;
                 });
             }
             catch (error) {
@@ -341,14 +340,6 @@ function clear(keysToPreserve = []) {
                 // If it isn't preserved and doesn't have a default, we'll remove it
                 keysToBeClearedFromStorage.push(key);
             }
-            const updatePromises = [];
-            // Notify the subscribers for each key/value group so they can receive the new values
-            for (const [key, value] of Object.entries(keyValuesToResetIndividually)) {
-                updatePromises.push(OnyxUtils_1.default.scheduleSubscriberUpdate(key, value));
-            }
-            for (const [key, value] of Object.entries(keyValuesToResetAsCollection)) {
-                updatePromises.push(OnyxUtils_1.default.scheduleNotifyCollectionSubscribers(key, value.newValues, value.oldValues));
-            }
             // Exclude RAM-only keys to prevent them from being saved to storage
             const defaultKeyValuePairs = Object.entries(Object.keys(defaultKeyStates)
                 .filter((key) => !keysToPreserve.includes(key) && !OnyxUtils_1.default.isRamOnlyKey(key))
@@ -365,7 +356,13 @@ function clear(keysToPreserve = []) {
                 .then(() => storage_1.default.multiSet(defaultKeyValuePairs))
                 .then(() => {
                 DevTools_1.default.clearState(keysToPreserve);
-                return Promise.all(updatePromises);
+                // Notify the subscribers for each key/value group so they can receive the new values
+                for (const [key, value] of Object.entries(keyValuesToResetIndividually)) {
+                    OnyxUtils_1.default.keyChanged(key, value);
+                }
+                for (const [key, value] of Object.entries(keyValuesToResetAsCollection)) {
+                    OnyxUtils_1.default.keysChanged(key, value.newValues, value.oldValues);
+                }
             });
         })
             .then(() => undefined);

package/dist/OnyxMerge/index.js

@@ -13,17 +13,16 @@ 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);
+    OnyxUtils_1.default.broadcastUpdate(key, mergedValue, hasChanged);
     const shouldSkipStorageOperations = !hasChanged || OnyxUtils_1.default.isRamOnlyKey(key);
     // If the value has not changed, calling Storage.setItem() would be redundant and a waste of performance, so return early instead.
     // If the key is marked as RAM-only, it should not be saved nor updated in the storage.
     if (shouldSkipStorageOperations) {
-        return Promise.resolve({ mergedValue, updatePromise });
+        return Promise.resolve({ mergedValue });
     }
     // For web platforms we use `setItem` since the object was already merged with its changes before.
     return storage_1.default.setItem(key, mergedValue).then(() => ({
         mergedValue,
-        updatePromise,
     }));
 };
 const OnyxMerge = {

package/dist/OnyxMerge/index.native.js

@@ -19,18 +19,17 @@ 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);
+    OnyxUtils_1.default.broadcastUpdate(key, mergedValue, hasChanged);
     const shouldSkipStorageOperations = !hasChanged || OnyxUtils_1.default.isRamOnlyKey(key);
     // If the value has not changed, calling Storage.setItem() would be redundant and a waste of performance, so return early instead.
     // If the key is marked as RAM-only, it should not be saved nor updated in the storage.
     if (shouldSkipStorageOperations) {
-        return Promise.resolve({ mergedValue, updatePromise });
+        return Promise.resolve({ mergedValue });
     }
     // For native platforms we use `mergeItem` that will take advantage of JSON_PATCH and JSON_REPLACE SQL operations to
     // merge the object in a performant way.
     return storage_1.default.mergeItem(key, batchedChanges, replaceNullPatches).then(() => ({
         mergedValue,
-        updatePromise,
     }));
 };
 const OnyxMerge = {

package/dist/OnyxMerge/types.d.ts

@@ -1,7 +1,6 @@
 import type { OnyxInput, OnyxKey } from '../types';
 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>>;
 export type { ApplyMerge, ApplyMergeResult };

package/dist/OnyxSnapshotCache.d.ts

@@ -39,12 +39,11 @@ declare class OnyxSnapshotCache {
      *
      * - `selector`: Different selectors produce different results, so each selector needs its own cache entry
      * - `initWithStoredValues`: This flag changes the initial loading behavior and affects the returned fetch status
-     * - `allowStaleData`: Controls whether stale data can be returned during pending merges, affecting result timing
      *
      * Other options like `canEvict`, `reuseConnection`, and `allowDynamicKey` don't affect the data transformation
      * or timing behavior of getSnapshot, so they're excluded from the cache key for better cache hit rates.
      */
-    registerConsumer<TKey extends OnyxKey, TReturnValue>(options: Pick<UseOnyxOptions<TKey, TReturnValue>, 'selector' | 'initWithStoredValues' | 'allowStaleData'>): string;
+    registerConsumer<TKey extends OnyxKey, TReturnValue>(options: Pick<UseOnyxOptions<TKey, TReturnValue>, 'selector' | 'initWithStoredValues'>): string;
     /**
      * Deregister a consumer for a cache key.
      * Decrements reference counter and removes cache entry if no consumers remain.

package/dist/OnyxSnapshotCache.js

@@ -36,18 +36,16 @@ class OnyxSnapshotCache {
      *
      * - `selector`: Different selectors produce different results, so each selector needs its own cache entry
      * - `initWithStoredValues`: This flag changes the initial loading behavior and affects the returned fetch status
-     * - `allowStaleData`: Controls whether stale data can be returned during pending merges, affecting result timing
      *
      * Other options like `canEvict`, `reuseConnection`, and `allowDynamicKey` don't affect the data transformation
      * or timing behavior of getSnapshot, so they're excluded from the cache key for better cache hit rates.
      */
     registerConsumer(options) {
-        var _a, _b;
+        var _a;
         const selectorID = (options === null || options === void 0 ? void 0 : options.selector) ? this.getSelectorID(options.selector) : 'no_selector';
         // Create options hash without expensive JSON.stringify
         const initWithStoredValues = (_a = options === null || options === void 0 ? void 0 : options.initWithStoredValues) !== null && _a !== void 0 ? _a : true;
-        const allowStaleData = (_b = options === null || options === void 0 ? void 0 : options.allowStaleData) !== null && _b !== void 0 ? _b : false;
-        const cacheKey = `${selectorID}_${initWithStoredValues}_${allowStaleData}`;
+        const cacheKey = `${selectorID}_${initWithStoredValues}`;
         // Increment reference count for this cache key
         const currentCount = this.cacheKeyRefCounts.get(cacheKey) || 0;
         this.cacheKeyRefCounts.set(cacheKey, currentCount + 1);

package/dist/OnyxUtils.d.ts

@@ -186,7 +186,7 @@ declare function keyChanged<TKey extends OnyxKey>(key: TKey, value: OnyxValue<TK
 /**
  * Sends the data obtained from the keys to the connection.
  */
-declare function sendDataToConnection<TKey extends OnyxKey>(mapping: CallbackToStateMapping<TKey>, value: OnyxValue<TKey> | null, matchedKey: TKey | undefined): void;
+declare function sendDataToConnection<TKey extends OnyxKey>(mapping: CallbackToStateMapping<TKey>, matchedKey: TKey | undefined): void;
 /**
  * We check to see if this key is flagged as safe for eviction and add it to the recentlyAccessedKeys list so that when we
  * run out of storage the least recently accessed key can be removed.
@@ -196,19 +196,6 @@ declare function addKeyToRecentlyAccessedIfNeeded<TKey extends OnyxKey>(key: TKe
  * Gets the data for a given an array of matching keys, combines them into an object, and sends the result back to the subscriber.
  */
 declare function getCollectionDataAndSendAsObject<TKey extends OnyxKey>(matchingKeys: CollectionKeyBase[], mapping: CallbackToStateMapping<TKey>): void;
-/**
- * Schedules an update that will be appended to the macro task queue (so it doesn't update the subscribers immediately).
- *
- * @example
- * scheduleSubscriberUpdate(key, value, subscriber => subscriber.initWithStoredValues === false)
- */
-declare function scheduleSubscriberUpdate<TKey extends OnyxKey>(key: TKey, value: OnyxValue<TKey>, canUpdateSubscriber?: (subscriber?: CallbackToStateMapping<OnyxKey>) => boolean, isProcessingCollectionUpdate?: boolean): Promise<void>;
-/**
- * This method is similar to scheduleSubscriberUpdate 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>;
 /**
  * Remove a key from Onyx and update the subscribers
  */
@@ -224,7 +211,7 @@ declare function retryOperation<TMethod extends RetriableOnyxOperation>(error: E
 /**
  * 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): void;
 declare function hasPendingMergeForKey(key: OnyxKey): boolean;
 /**
  * Storage expects array like: [["@MyApp_user", value_1], ["@MyApp_key", value_2]]
@@ -370,8 +357,6 @@ declare const OnyxUtils: {
     sendDataToConnection: typeof sendDataToConnection;
     getCollectionKey: typeof getCollectionKey;
     getCollectionDataAndSendAsObject: typeof getCollectionDataAndSendAsObject;
-    scheduleSubscriberUpdate: typeof scheduleSubscriberUpdate;
-    scheduleNotifyCollectionSubscribers: typeof scheduleNotifyCollectionSubscribers;
     remove: typeof remove;
     reportStorageQuota: typeof reportStorageQuota;
     retryOperation: typeof retryOperation;

package/dist/OnyxUtils.js

@@ -74,8 +74,6 @@ const MAX_STORAGE_OPERATION_RETRY_ATTEMPTS = 5;
 // Key/value store of Onyx key and arrays of values to merge
 let mergeQueue = {};
 let mergeQueuePromise = {};
-// Used to schedule subscriber update to the macro task queue
-let nextMacrotaskPromise = null;
 // Holds a mapping of all the React components that want their state subscribed to a store key
 let callbackToStateMapping = {};
 // Keeps a copy of the values of the onyx collection keys as a map for faster lookups
@@ -586,6 +584,7 @@ function keysChanged(collectionKey, partialCollection, partialPreviousCollection
             // If they are subscribed to the collection key and using waitForCollectionCallback then we'll
             // send the whole cached collection.
             if (isSubscribedToCollectionKey) {
+                lastConnectionCallbackData.set(subscriber.subscriptionID, cachedCollection);
                 if (subscriber.waitForCollectionCallback) {
                     subscriber.callback(cachedCollection, subscriber.key, partialCollection);
                     continue;
@@ -668,6 +667,7 @@ function keyChanged(key, value, canUpdateSubscriber = () => true, isProcessingCo
                     cachedCollections[subscriber.key] = cachedCollection;
                 }
                 cachedCollection[key] = value;
+                lastConnectionCallbackData.set(subscriber.subscriptionID, cachedCollection);
                 subscriber.callback(cachedCollection, subscriber.key, { [key]: value });
                 continue;
             }
@@ -682,22 +682,32 @@ function keyChanged(key, value, canUpdateSubscriber = () => true, isProcessingCo
 /**
  * Sends the data obtained from the keys to the connection.
  */
-function sendDataToConnection(mapping, value, matchedKey) {
+function sendDataToConnection(mapping, matchedKey) {
     var _a, _b;
     // If the mapping no longer exists then we should not send any data.
     // This means our subscriber was disconnected.
     if (!callbackToStateMapping[mapping.subscriptionID]) {
         return;
     }
+    // Always read the latest value from cache to avoid stale or duplicate data.
+    // For collection subscribers with waitForCollectionCallback, read the full collection.
+    // For individual key subscribers, read just that key's value.
+    let value;
+    if (isCollectionKey(mapping.key) && mapping.waitForCollectionCallback) {
+        const collection = getCachedCollection(mapping.key);
+        value = Object.keys(collection).length > 0 ? collection : undefined;
+    }
+    else {
+        value = OnyxCache_1.default.get(matchedKey !== null && matchedKey !== void 0 ? matchedKey : mapping.key);
+    }
     // For regular callbacks, we never want to pass null values, but always just undefined if a value is not set in cache or storage.
-    const valueToPass = value === null ? undefined : value;
+    value = value === null ? undefined : value;
     const lastValue = lastConnectionCallbackData.get(mapping.subscriptionID);
-    lastConnectionCallbackData.get(mapping.subscriptionID);
     // If the value has not changed we do not need to trigger the callback
-    if (lastConnectionCallbackData.has(mapping.subscriptionID) && valueToPass === lastValue) {
+    if (lastConnectionCallbackData.has(mapping.subscriptionID) && (0, fast_equals_1.shallowEqual)(lastValue, value)) {
         return;
     }
-    (_b = (_a = mapping).callback) === null || _b === void 0 ? void 0 : _b.call(_a, valueToPass, matchedKey);
+    (_b = (_a = mapping).callback) === null || _b === void 0 ? void 0 : _b.call(_a, value, matchedKey);
 }
 /**
  * We check to see if this key is flagged as safe for eviction and add it to the recentlyAccessedKeys list so that when we
@@ -716,50 +726,16 @@ function addKeyToRecentlyAccessedIfNeeded(key) {
  * Gets the data for a given an array of matching keys, combines them into an object, and sends the result back to the subscriber.
  */
 function getCollectionDataAndSendAsObject(matchingKeys, mapping) {
-    multiGet(matchingKeys).then((dataMap) => {
-        const data = Object.fromEntries(dataMap.entries());
-        sendDataToConnection(mapping, data, mapping.key);
+    multiGet(matchingKeys).then(() => {
+        sendDataToConnection(mapping, mapping.key);
     });
 }
-/**
- * Delays promise resolution until the next macrotask to prevent race condition if the key subscription is in progress.
- *
- * @param callback The keyChanged/keysChanged callback
- * */
-function prepareSubscriberUpdate(callback) {
-    if (!nextMacrotaskPromise) {
-        nextMacrotaskPromise = new Promise((resolve) => {
-            setTimeout(() => {
-                nextMacrotaskPromise = null;
-                resolve();
-            }, 0);
-        });
-    }
-    return Promise.all([nextMacrotaskPromise, Promise.resolve().then(callback)]).then();
-}
-/**
- * Schedules an update that will be appended to the macro task queue (so it doesn't update the subscribers immediately).
- *
- * @example
- * scheduleSubscriberUpdate(key, value, subscriber => subscriber.initWithStoredValues === false)
- */
-function scheduleSubscriberUpdate(key, value, canUpdateSubscriber = () => true, isProcessingCollectionUpdate = false) {
-    return prepareSubscriberUpdate(() => keyChanged(key, value, canUpdateSubscriber, isProcessingCollectionUpdate));
-}
-/**
- * This method is similar to scheduleSubscriberUpdate 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.
- */
-function scheduleNotifyCollectionSubscribers(key, value, previousValue) {
-    return prepareSubscriberUpdate(() => keysChanged(key, value, previousValue));
-}
 /**
  * Remove a key from Onyx and update the subscribers
  */
 function remove(key, isProcessingCollectionUpdate) {
     OnyxCache_1.default.drop(key);
-    scheduleSubscriberUpdate(key, undefined, undefined, isProcessingCollectionUpdate);
+    keyChanged(key, undefined, undefined, isProcessingCollectionUpdate);
     if (isRamOnlyKey(key)) {
         return Promise.resolve();
     }
@@ -827,7 +803,7 @@ function broadcastUpdate(key, value, hasChanged) {
     else {
         OnyxCache_1.default.addToAccessedKeys(key);
     }
-    return scheduleSubscriberUpdate(key, value, (subscriber) => hasChanged || (subscriber === null || subscriber === void 0 ? void 0 : subscriber.initWithStoredValues) === false).then(() => undefined);
+    keyChanged(key, value, (subscriber) => hasChanged || (subscriber === null || subscriber === void 0 ? void 0 : subscriber.initWithStoredValues) === false);
 }
 function hasPendingMergeForKey(key) {
     return !!mergeQueue[key];
@@ -1002,7 +978,7 @@ function subscribeToKey(connectOptions) {
             const matchedKey = isCollectionKey(mapping.key) && mapping.waitForCollectionCallback ? mapping.key : undefined;
             // Here we cannot use batching because the nullish value is expected to be set immediately for default props
             // or they will be undefined.
-            sendDataToConnection(mapping, null, matchedKey);
+            sendDataToConnection(mapping, matchedKey);
             return;
         }
         // When using a callback subscriber we will either trigger the provided callback for each key we find or combine all values
@@ -1015,15 +991,15 @@ function subscribeToKey(connectOptions) {
                     return;
                 }
                 // We did not opt into using waitForCollectionCallback mode so the callback is called for every matching key.
-                multiGet(matchingKeys).then((values) => {
-                    for (const [key, val] of values.entries()) {
-                        sendDataToConnection(mapping, val, key);
+                multiGet(matchingKeys).then(() => {
+                    for (const key of matchingKeys) {
+                        sendDataToConnection(mapping, key);
                     }
                 });
                 return;
             }
             // If we are not subscribed to a collection key then there's only a single key to send an update for.
-            get(mapping.key).then((val) => sendDataToConnection(mapping, val, mapping.key));
+            get(mapping.key).then(() => sendDataToConnection(mapping, mapping.key));
             return;
         }
         console.error('Warning: Onyx.connect() was found without a callback');
@@ -1151,21 +1127,20 @@ function setWithRetry({ key, value, options }, retryAttempt) {
     const hasChanged = (options === null || options === void 0 ? void 0 : options.skipCacheCheck) ? true : OnyxCache_1.default.hasValueChanged(key, valueWithoutNestedNullValues);
     OnyxUtils.logKeyChanged(OnyxUtils.METHOD.SET, key, value, hasChanged);
     // This approach prioritizes fast UI changes without waiting for data to be stored in device storage.
-    const updatePromise = OnyxUtils.broadcastUpdate(key, valueWithoutNestedNullValues, hasChanged);
+    OnyxUtils.broadcastUpdate(key, valueWithoutNestedNullValues, hasChanged);
     // If the value has not changed and this isn't a retry attempt, calling Storage.setItem() would be redundant and a waste of performance, so return early instead.
     if (!hasChanged && !retryAttempt) {
-        return updatePromise;
+        return Promise.resolve();
     }
     // If a key is a RAM-only key or a member of RAM-only collection, we skip the step that modifies the storage
     if (isRamOnlyKey(key)) {
         OnyxUtils.sendActionToDevTools(OnyxUtils.METHOD.SET, key, valueWithoutNestedNullValues);
-        return updatePromise;
+        return Promise.resolve();
     }
     return storage_1.default.setItem(key, valueWithoutNestedNullValues)
         .catch((error) => OnyxUtils.retryOperation(error, setWithRetry, { key, value: valueWithoutNestedNullValues, options }, retryAttempt))
         .then(() => {
         OnyxUtils.sendActionToDevTools(OnyxUtils.METHOD.SET, key, valueWithoutNestedNullValues);
-        return updatePromise;
     });
 }
 /**
@@ -1195,16 +1170,16 @@ function multiSetWithRetry(data, retryAttempt) {
         }, {});
     }
     const keyValuePairsToSet = OnyxUtils.prepareKeyValuePairsForStorage(newData, true);
-    const updatePromises = keyValuePairsToSet.map(([key, value]) => {
+    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 on the next tick
+        // Update cache and optimistically inform subscribers
         OnyxCache_1.default.set(key, value);
-        return OnyxUtils.scheduleSubscriberUpdate(key, value);
-    });
+        keyChanged(key, value);
+    }
     const keyValuePairsToStore = keyValuePairsToSet.filter((keyValuePair) => {
         const [key] = keyValuePair;
         // Filter out the RAM-only key value pairs, as they should not be saved to storage
@@ -1214,9 +1189,7 @@ function multiSetWithRetry(data, retryAttempt) {
         .catch((error) => OnyxUtils.retryOperation(error, multiSetWithRetry, newData, retryAttempt))
         .then(() => {
         OnyxUtils.sendActionToDevTools(OnyxUtils.METHOD.MULTI_SET, undefined, newData);
-        return Promise.all(updatePromises);
-    })
-        .then(() => undefined);
+    });
 }
 /**
  * Sets a collection by replacing all existing collection members with new values.
@@ -1269,17 +1242,16 @@ function setCollectionWithRetry({ collectionKey, collection }, retryAttempt) {
         const previousCollection = OnyxUtils.getCachedCollection(collectionKey);
         for (const [key, value] of keyValuePairs)
             OnyxCache_1.default.set(key, value);
-        const updatePromise = OnyxUtils.scheduleNotifyCollectionSubscribers(collectionKey, mutableCollection, previousCollection);
+        keysChanged(collectionKey, mutableCollection, previousCollection);
         // RAM-only keys are not supposed to be saved to storage
         if (isRamOnlyKey(collectionKey)) {
             OnyxUtils.sendActionToDevTools(OnyxUtils.METHOD.SET_COLLECTION, undefined, mutableCollection);
-            return updatePromise;
+            return;
         }
         return storage_1.default.multiSet(keyValuePairs)
             .catch((error) => OnyxUtils.retryOperation(error, setCollectionWithRetry, { collectionKey, collection }, retryAttempt))
             .then(() => {
             OnyxUtils.sendActionToDevTools(OnyxUtils.METHOD.SET_COLLECTION, undefined, mutableCollection);
-            return updatePromise;
         });
     });
 }
@@ -1380,7 +1352,7 @@ function mergeCollectionWithPatches({ collectionKey, collection, mergeReplaceNul
         // and update all subscribers
         const promiseUpdate = previousCollectionPromise.then((previousCollection) => {
             OnyxCache_1.default.merge(finalMergedCollection);
-            return scheduleNotifyCollectionSubscribers(collectionKey, finalMergedCollection, previousCollection);
+            keysChanged(collectionKey, finalMergedCollection, previousCollection);
         });
         return Promise.all(promises)
             .catch((error) => retryOperation(error, mergeCollectionWithPatches, { collectionKey, collection: resultCollection, mergeReplaceNullPatches, isProcessingCollectionUpdate }, retryAttempt))
@@ -1433,16 +1405,15 @@ function partialSetCollection({ collectionKey, collection }, retryAttempt) {
         const keyValuePairs = prepareKeyValuePairsForStorage(mutableCollection, true, undefined, true);
         for (const [key, value] of keyValuePairs)
             OnyxCache_1.default.set(key, value);
-        const updatePromise = scheduleNotifyCollectionSubscribers(collectionKey, mutableCollection, previousCollection);
+        keysChanged(collectionKey, mutableCollection, previousCollection);
         if (isRamOnlyKey(collectionKey)) {
             sendActionToDevTools(METHOD.SET_COLLECTION, undefined, mutableCollection);
-            return updatePromise;
+            return;
         }
         return storage_1.default.multiSet(keyValuePairs)
             .catch((error) => retryOperation(error, partialSetCollection, { collectionKey, collection }, retryAttempt))
             .then(() => {
             sendActionToDevTools(METHOD.SET_COLLECTION, undefined, mutableCollection);
-            return updatePromise;
         });
     });
 }
@@ -1486,8 +1457,6 @@ const OnyxUtils = {
     sendDataToConnection,
     getCollectionKey,
     getCollectionDataAndSendAsObject,
-    scheduleSubscriberUpdate,
-    scheduleNotifyCollectionSubscribers,
     remove,
     reportStorageQuota,
     retryOperation,
@@ -1542,10 +1511,6 @@ GlobalSettings.addGlobalSettingsChangeListener(({ enablePerformanceMetrics }) =>
     // @ts-expect-error Reassign
     sendDataToConnection = (0, metrics_1.default)(sendDataToConnection, 'OnyxUtils.sendDataToConnection');
     // @ts-expect-error Reassign
-    scheduleSubscriberUpdate = (0, metrics_1.default)(scheduleSubscriberUpdate, 'OnyxUtils.scheduleSubscriberUpdate');
-    // @ts-expect-error Reassign
-    scheduleNotifyCollectionSubscribers = (0, metrics_1.default)(scheduleNotifyCollectionSubscribers, 'OnyxUtils.scheduleNotifyCollectionSubscribers');
-    // @ts-expect-error Reassign
     remove = (0, metrics_1.default)(remove, 'OnyxUtils.remove');
     // @ts-expect-error Reassign
     reportStorageQuota = (0, metrics_1.default)(reportStorageQuota, 'OnyxUtils.reportStorageQuota');

package/dist/useOnyx.d.ts

@@ -11,10 +11,6 @@ type UseOnyxOptions<TKey extends OnyxKey, TReturnValue> = {
      * @deprecated This param is going to be removed soon. Use RAM-only keys instead.
      */
     initWithStoredValues?: boolean;
-    /**
-     * If set to `true`, data will be retrieved from cache during the first render even if there is a pending merge for the key.
-     */
-    allowStaleData?: boolean;
     /**
      * If set to `false`, the connection won't be reused between other subscribers that are listening to the same Onyx key
      * with the same connect configurations.

package/dist/useOnyx.js

@@ -109,8 +109,7 @@ function useOnyx(key, options, dependencies = []) {
     const cacheKey = (0, react_1.useMemo)(() => OnyxSnapshotCache_1.default.registerConsumer({
         selector: options === null || options === void 0 ? void 0 : options.selector,
         initWithStoredValues: options === null || options === void 0 ? void 0 : options.initWithStoredValues,
-        allowStaleData: options === null || options === void 0 ? void 0 : options.allowStaleData,
-    }), [options === null || options === void 0 ? void 0 : options.selector, options === null || options === void 0 ? void 0 : options.initWithStoredValues, options === null || options === void 0 ? void 0 : options.allowStaleData]);
+    }), [options === null || options === void 0 ? void 0 : options.selector, options === null || options === void 0 ? void 0 : options.initWithStoredValues]);
     (0, react_1.useEffect)(() => () => OnyxSnapshotCache_1.default.deregisterConsumer(key, cacheKey), [key, cacheKey]);
     (0, react_1.useEffect)(() => {
         // These conditions will ensure we can only handle dynamic collection member keys from the same collection.
@@ -206,8 +205,7 @@ function useOnyx(key, options, dependencies = []) {
         let newFetchStatus;
         // If we have pending merge operations for the key during the first connection, we set the new value to `undefined`
         // and fetch status to `loading` to simulate that it is still being loaded until we have the most updated data.
-        // If `allowStaleData` is `true` this logic will be ignored and cached value will be used, even if it's stale data.
-        if (isFirstConnectionRef.current && OnyxUtils_1.default.hasPendingMergeForKey(key) && !(options === null || options === void 0 ? void 0 : options.allowStaleData)) {
+        if (isFirstConnectionRef.current && OnyxUtils_1.default.hasPendingMergeForKey(key)) {
             newValueRef.current = undefined;
             newFetchStatus = 'loading';
         }
@@ -248,7 +246,7 @@ function useOnyx(key, options, dependencies = []) {
             OnyxSnapshotCache_1.default.setCachedResult(key, cacheKey, resultRef.current);
         }
         return resultRef.current;
-    }, [options === null || options === void 0 ? void 0 : options.initWithStoredValues, options === null || options === void 0 ? void 0 : options.allowStaleData, key, memoizedSelector, cacheKey, previousKey]);
+    }, [options === null || options === void 0 ? void 0 : options.initWithStoredValues, key, memoizedSelector, cacheKey, previousKey]);
     const subscribe = (0, react_1.useCallback)((onStoreChange) => {
         isConnectingRef.current = true;
         onStoreChangeFnRef.current = onStoreChange;

package/package.json

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