react-native-onyx 3.0.20 → 3.0.22

package/dist/Onyx.d.ts

@@ -139,7 +139,7 @@ declare function clear(keysToPreserve?: OnyxKey[]): Promise<void>;
  * @param data An array of objects with update expressions
  * @returns resolves when all operations are complete
  */
-declare function update(data: OnyxUpdate[]): Promise<void>;
+declare function update<TKey extends OnyxKey>(data: Array<OnyxUpdate<TKey>>): Promise<void>;
 /**
  * Sets a collection by replacing all existing collection members with new values.
  * Any existing collection members not included in the new data will be removed.

package/dist/OnyxUtils.d.ts

@@ -241,7 +241,7 @@ declare function subscribeToKey<TKey extends OnyxKey>(connectOptions: ConnectOpt
  * @param subscriptionID Subscription ID returned by calling `OnyxUtils.subscribeToKey()`.
  */
 declare function unsubscribeFromKey(subscriptionID: number): void;
-declare function updateSnapshots(data: OnyxUpdate[], mergeFn: typeof Onyx.merge): Array<() => Promise<void>>;
+declare function updateSnapshots<TKey extends OnyxKey>(data: Array<OnyxUpdate<TKey>>, mergeFn: typeof Onyx.merge): Array<() => Promise<void>>;
 /**
  * Writes a value to our store with the given key.
  * Serves as core implementation for `Onyx.set()` public function, the difference being

package/dist/OnyxUtils.js

@@ -465,81 +465,6 @@ 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);
@@ -1270,9 +1195,8 @@ function setCollectionWithRetry({ collectionKey, collection }, retryAttempt) {
         });
         const keyValuePairs = OnyxUtils.prepareKeyValuePairsForStorage(mutableCollection, true, undefined, true);
         const previousCollection = OnyxUtils.getCachedCollection(collectionKey);
-        // 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);
+        keyValuePairs.forEach(([key, value]) => OnyxCache_1.default.set(key, value));
+        const updatePromise = OnyxUtils.scheduleNotifyCollectionSubscribers(collectionKey, mutableCollection, previousCollection);
         return storage_1.default.multiSet(keyValuePairs)
             .catch((error) => OnyxUtils.retryOperation(error, setCollectionWithRetry, { collectionKey, collection }, retryAttempt))
             .then(() => {
@@ -1324,8 +1248,6 @@ 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) {
@@ -1335,8 +1257,6 @@ 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]);
@@ -1365,8 +1285,7 @@ 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.
-        // 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);
+        const previousCollectionPromise = Promise.all(existingKeys.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) {
@@ -1380,16 +1299,8 @@ 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);
-            // 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 scheduleNotifyCollectionSubscribers(collectionKey, finalMergedCollection, previousCollection);
         });
         return Promise.all(promises)
             .catch((error) => retryOperation(error, mergeCollectionWithPatches, { collectionKey, collection: resultCollection, mergeReplaceNullPatches, isProcessingCollectionUpdate }, retryAttempt))
@@ -1440,9 +1351,8 @@ 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);
-        // Preserve references for unchanged items and include removed items as null in partialSetCollection
-        const preservedCollection = preserveCollectionReferences(keyValuePairs, previousCollection);
-        const updatePromise = scheduleNotifyCollectionSubscribers(collectionKey, preservedCollection, previousCollection);
+        keyValuePairs.forEach(([key, value]) => OnyxCache_1.default.set(key, value));
+        const updatePromise = scheduleNotifyCollectionSubscribers(collectionKey, mutableCollection, previousCollection);
         return storage_1.default.multiSet(keyValuePairs)
             .catch((error) => retryOperation(error, partialSetCollection, { collectionKey, collection }, retryAttempt))
             .then(() => {

package/dist/types.d.ts

@@ -175,9 +175,7 @@ type NullishObjectDeep<ObjectType extends object> = {
  * Also, the `TMap` type is inferred automatically in `mergeCollection()` method and represents
  * the object of collection keys/values specified in the second parameter of the method.
  */
-type Collection<TKey extends CollectionKeyBase, TValue> = Record<`${TKey}${string}`, TValue> & {
-    [P in TKey]?: never;
-};
+type Collection<TKey extends CollectionKeyBase, TValue> = Record<`${TKey}${string}`, TValue>;
 /** Represents the base options used in `Onyx.connect()` method. */
 type BaseConnectOptions = {
     /** If set to `false`, then the initial data will be only sent to the callback function if it changes. */
@@ -270,40 +268,39 @@ type OnyxMergeCollectionInput<TKey extends OnyxKey> = Collection<TKey, NonNullab
  */
 type OnyxSetCollectionInput<TKey extends OnyxKey> = Collection<TKey, OnyxInput<TKey>>;
 type OnyxMethodMap = typeof OnyxUtils.METHOD;
+type ExpandOnyxKeys<TKey extends OnyxKey> = TKey extends CollectionKeyBase ? NoInfer<`${TKey}${string}`> : TKey;
 /**
  * OnyxUpdate type includes all onyx methods used in OnyxMethodValueMap.
  * If a new method is added to OnyxUtils.METHOD constant, it must be added to OnyxMethodValueMap type.
  * Otherwise it will show static type errors.
  */
-type OnyxUpdate = {
-    [TKey in OnyxKey]: {
+type OnyxUpdate<TKey extends OnyxKey = OnyxKey> = {
+    [K in TKey]: {
         onyxMethod: typeof OnyxUtils.METHOD.SET;
-        key: TKey;
-        value: OnyxSetInput<TKey>;
+        key: ExpandOnyxKeys<K>;
+        value: OnyxSetInput<K>;
     } | {
         onyxMethod: typeof OnyxUtils.METHOD.MULTI_SET;
-        key: TKey;
+        key: ExpandOnyxKeys<K>;
         value: OnyxMultiSetInput;
     } | {
         onyxMethod: typeof OnyxUtils.METHOD.MERGE;
-        key: TKey;
-        value: OnyxMergeInput<TKey>;
+        key: ExpandOnyxKeys<K>;
+        value: OnyxMergeInput<K>;
     } | {
         onyxMethod: typeof OnyxUtils.METHOD.CLEAR;
-        key: TKey;
-        value?: undefined;
-    };
-}[OnyxKey] | {
-    [TKey in CollectionKeyBase]: {
+        key: ExpandOnyxKeys<K>;
+        value?: never;
+    } | {
         onyxMethod: typeof OnyxUtils.METHOD.MERGE_COLLECTION;
-        key: TKey;
-        value: OnyxMergeCollectionInput<TKey>;
+        key: K;
+        value: OnyxMergeCollectionInput<K>;
     } | {
         onyxMethod: typeof OnyxUtils.METHOD.SET_COLLECTION;
-        key: TKey;
-        value: OnyxSetCollectionInput<TKey>;
+        key: K;
+        value: OnyxSetCollectionInput<K>;
     };
-}[CollectionKeyBase];
+}[TKey];
 /**
  * Represents the options used in `Onyx.set()` method.
  */

package/package.json

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