react-native-onyx 3.0.18 → 3.0.20

package/dist/OnyxUtils.js

@@ -465,6 +465,81 @@ function tryGetCachedValue(key) {
     }
     return val;
 }
+/**
+ * Marks items that existed in previousCollection but not in preservedCollection as null.
+ * This ensures subscribers are properly notified about item removals.
+ * @param preservedCollection - The collection to mark removed items in (mutated in place)
+ * @param previousCollection - The previous collection state to compare against
+ */
+function markRemovedItemsAsNull(preservedCollection, previousCollection) {
+    if (!previousCollection) {
+        return preservedCollection;
+    }
+    const mutablePreservedCollection = Object.assign({}, preservedCollection);
+    Object.keys(previousCollection).forEach((key) => {
+        if (key in preservedCollection) {
+            return;
+        }
+        mutablePreservedCollection[key] = null;
+    });
+    return mutablePreservedCollection;
+}
+/**
+ * Utility function to preserve object references for unchanged items in collection operations.
+ * Compares new values with cached values using deep equality and preserves references when data is identical.
+ * @param keyValuePairs - Array of key-value pairs to process
+ * @param previousCollection - Optional previous collection state. If provided, removed items will be included as null
+ * @returns The preserved collection with unchanged references maintained and removed items marked as null
+ */
+function preserveCollectionReferences(keyValuePairs, previousCollection) {
+    const preservedCollection = {};
+    keyValuePairs.forEach(([key, value]) => {
+        const cachedValue = OnyxCache_1.default.get(key, false);
+        // If no cached value exists, we need to add the new value (skip expensive deep equality check)
+        // Use deep equality check to preserve references for unchanged items
+        if (cachedValue !== undefined && (0, fast_equals_1.deepEqual)(value, cachedValue)) {
+            // Keep the existing reference
+            preservedCollection[key] = cachedValue;
+        }
+        else {
+            // Update cache only for changed items
+            OnyxCache_1.default.set(key, value);
+            preservedCollection[key] = value;
+        }
+    });
+    if (previousCollection) {
+        return markRemovedItemsAsNull(preservedCollection, previousCollection);
+    }
+    return preservedCollection;
+}
+/**
+ * Utility function for merge operations that preserves references after cache merge has been performed.
+ * Compares merged values with original cached values and preserves references when data is unchanged.
+ * @param collection - Collection of merged data
+ * @param originalCachedValues - Original cached values before merge
+ * @param previousCollection - Optional previous collection state. If provided, removed items will be included as null
+ * @returns The preserved collection with unchanged references maintained and removed items marked as null
+ */
+function preserveCollectionReferencesAfterMerge(collection, originalCachedValues, previousCollection) {
+    const preservedCollection = {};
+    Object.keys(collection).forEach((key) => {
+        const newMergedValue = OnyxCache_1.default.get(key, false);
+        const originalValue = originalCachedValues[key];
+        // Use deep equality check to preserve references for unchanged items
+        if (originalValue !== undefined && (0, fast_equals_1.deepEqual)(newMergedValue, originalValue)) {
+            // Keep the existing reference and update cache
+            preservedCollection[key] = originalValue;
+            OnyxCache_1.default.set(key, originalValue);
+        }
+        else {
+            preservedCollection[key] = newMergedValue;
+        }
+    });
+    if (previousCollection) {
+        return markRemovedItemsAsNull(preservedCollection, previousCollection);
+    }
+    return preservedCollection;
+}
 function getCachedCollection(collectionKey, collectionMemberKeys) {
     // Use optimized collection data retrieval when cache is populated
     const collectionData = OnyxCache_1.default.getCollectionData(collectionKey);
@@ -1195,8 +1270,9 @@ function setCollectionWithRetry({ collectionKey, collection }, retryAttempt) {
         });
         const keyValuePairs = OnyxUtils.prepareKeyValuePairsForStorage(mutableCollection, true, undefined, true);
         const previousCollection = OnyxUtils.getCachedCollection(collectionKey);
-        keyValuePairs.forEach(([key, value]) => OnyxCache_1.default.set(key, value));
-        const updatePromise = OnyxUtils.scheduleNotifyCollectionSubscribers(collectionKey, mutableCollection, previousCollection);
+        // Preserve references for unchanged items and include removed items as null in setCollection
+        const preservedCollection = preserveCollectionReferences(keyValuePairs, previousCollection);
+        const updatePromise = OnyxUtils.scheduleNotifyCollectionSubscribers(collectionKey, preservedCollection, previousCollection);
         return storage_1.default.multiSet(keyValuePairs)
             .catch((error) => OnyxUtils.retryOperation(error, setCollectionWithRetry, { collectionKey, collection }, retryAttempt))
             .then(() => {
@@ -1248,6 +1324,8 @@ function mergeCollectionWithPatches({ collectionKey, collection, mergeReplaceNul
     resultCollectionKeys = Object.keys(resultCollection);
     return getAllKeys()
         .then((persistedKeys) => {
+        // Capture keys that will be removed (before calling remove())
+        const keysToRemove = resultCollectionKeys.filter((key) => resultCollection[key] === null && persistedKeys.has(key));
         // Split to keys that exist in storage and keys that don't
         const keys = resultCollectionKeys.filter((key) => {
             if (resultCollection[key] === null) {
@@ -1257,6 +1335,8 @@ function mergeCollectionWithPatches({ collectionKey, collection, mergeReplaceNul
             return true;
         });
         const existingKeys = keys.filter((key) => persistedKeys.has(key));
+        // Get previous values for both existing keys and keys that will be removed
+        const allAffectedKeys = [...existingKeys, ...keysToRemove];
         const cachedCollectionForExistingKeys = getCachedCollection(collectionKey, existingKeys);
         const existingKeyCollection = existingKeys.reduce((obj, key) => {
             const { isCompatible, existingValueType, newValueType } = utils_1.default.checkCompatibilityWithExistingValue(resultCollection[key], cachedCollectionForExistingKeys[key]);
@@ -1285,7 +1365,8 @@ function mergeCollectionWithPatches({ collectionKey, collection, mergeReplaceNul
         const promises = [];
         // We need to get the previously existing values so we can compare the new ones
         // against them, to avoid unnecessary subscriber updates.
-        const previousCollectionPromise = Promise.all(existingKeys.map((key) => get(key).then((value) => [key, value]))).then(Object.fromEntries);
+        // Include keys that will be removed so subscribers are notified about removals
+        const previousCollectionPromise = Promise.all(allAffectedKeys.map((key) => get(key).then((value) => [key, value]))).then(Object.fromEntries);
         // New keys will be added via multiSet while existing keys will be updated using multiMerge
         // This is because setting a key that doesn't exist yet with multiMerge will throw errors
         if (keyValuePairsForExistingCollection.length > 0) {
@@ -1299,8 +1380,16 @@ function mergeCollectionWithPatches({ collectionKey, collection, mergeReplaceNul
         // Prefill cache if necessary by calling get() on any existing keys and then merge original data to cache
         // and update all subscribers
         const promiseUpdate = previousCollectionPromise.then((previousCollection) => {
+            // Capture the original cached values before merging
+            const originalCachedValues = {};
+            Object.keys(finalMergedCollection).forEach((key) => {
+                originalCachedValues[key] = OnyxCache_1.default.get(key, false);
+            });
+            // Then merge all the data into cache as normal
             OnyxCache_1.default.merge(finalMergedCollection);
-            return scheduleNotifyCollectionSubscribers(collectionKey, finalMergedCollection, previousCollection);
+            // Finally, preserve references for items that didn't actually change and include removed items as null
+            const preservedCollection = preserveCollectionReferencesAfterMerge(finalMergedCollection, originalCachedValues, previousCollection);
+            return scheduleNotifyCollectionSubscribers(collectionKey, preservedCollection, previousCollection);
         });
         return Promise.all(promises)
             .catch((error) => retryOperation(error, mergeCollectionWithPatches, { collectionKey, collection: resultCollection, mergeReplaceNullPatches, isProcessingCollectionUpdate }, retryAttempt))
@@ -1351,8 +1440,9 @@ function partialSetCollection({ collectionKey, collection }, retryAttempt) {
         const existingKeys = resultCollectionKeys.filter((key) => persistedKeys.has(key));
         const previousCollection = getCachedCollection(collectionKey, existingKeys);
         const keyValuePairs = prepareKeyValuePairsForStorage(mutableCollection, true, undefined, true);
-        keyValuePairs.forEach(([key, value]) => OnyxCache_1.default.set(key, value));
-        const updatePromise = scheduleNotifyCollectionSubscribers(collectionKey, mutableCollection, previousCollection);
+        // Preserve references for unchanged items and include removed items as null in partialSetCollection
+        const preservedCollection = preserveCollectionReferences(keyValuePairs, previousCollection);
+        const updatePromise = scheduleNotifyCollectionSubscribers(collectionKey, preservedCollection, previousCollection);
         return storage_1.default.multiSet(keyValuePairs)
             .catch((error) => retryOperation(error, partialSetCollection, { collectionKey, collection }, retryAttempt))
             .then(() => {

package/dist/useOnyx.js

@@ -234,22 +234,24 @@ function useOnyx(key, options, dependencies = []) {
         if (shouldUpdateResult) {
             previousValueRef.current = newValueRef.current;
             // If the new value is `null` we default it to `undefined` to ensure the consumer gets a consistent result from the hook.
-            const newStatus = newFetchStatus !== null && newFetchStatus !== void 0 ? newFetchStatus : 'loaded';
+            newFetchStatus = newFetchStatus !== null && newFetchStatus !== void 0 ? newFetchStatus : 'loaded';
             resultRef.current = [
                 (_d = previousValueRef.current) !== null && _d !== void 0 ? _d : undefined,
                 {
-                    status: newStatus,
+                    status: newFetchStatus,
                     sourceValue: sourceValueRef.current,
                 },
             ];
             // If `canBeMissing` is set to `false` and the Onyx value of that key is not defined,
             // we log an alert so it can be acknowledged by the consumer. Additionally, we won't log alerts
             // if there's a `Onyx.clear()` task in progress.
-            if ((options === null || options === void 0 ? void 0 : options.canBeMissing) === false && newStatus === 'loaded' && !isOnyxValueDefined && !OnyxCache_1.default.hasPendingTask(OnyxCache_1.TASK.CLEAR)) {
+            if ((options === null || options === void 0 ? void 0 : options.canBeMissing) === false && newFetchStatus === 'loaded' && !isOnyxValueDefined && !OnyxCache_1.default.hasPendingTask(OnyxCache_1.TASK.CLEAR)) {
                 Logger.logAlert(`useOnyx returned no data for key with canBeMissing set to false for key ${key}`, { showAlert: true });
             }
         }
-        OnyxSnapshotCache_1.default.setCachedResult(key, cacheKey, resultRef.current);
+        if (newFetchStatus !== 'loading') {
+            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, options === null || options === void 0 ? void 0 : options.canBeMissing, key, memoizedSelector, cacheKey]);
     const subscribe = (0, react_1.useCallback)((onStoreChange) => {

package/package.json

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