react-native-onyx 3.0.27 → 3.0.29

package/dist/GlobalSettings.js

@@ -17,7 +17,8 @@ function addGlobalSettingsChangeListener(listener) {
     };
 }
 function notifyListeners() {
-    listeners.forEach((listener) => listener(globalSettings));
+    for (const listener of listeners)
+        listener(globalSettings);
 }
 function setPerformanceMetricsEnabled(enabled) {
     globalSettings.enablePerformanceMetrics = enabled;

package/dist/Onyx.js

@@ -286,6 +286,7 @@ function clear(keysToPreserve = []) {
     const initialKeys = Object.keys(defaultKeyStates);
     const promise = OnyxUtils_1.default.getAllKeys()
         .then((cachedKeys) => {
+        var _a;
         OnyxCache_1.default.clearNullishStorageKeys();
         const keysToBeClearedFromStorage = [];
         const keyValuesToResetAsCollection = {};
@@ -297,8 +298,7 @@ function clear(keysToPreserve = []) {
         // 2. Any keys with a default state (because they need to remain in Onyx as their default, and setting them
         //      to null would cause unknown behavior)
         //   2.1 However, if a default key was explicitly set to null, we need to reset it to the default value
-        allKeys.forEach((key) => {
-            var _a;
+        for (const key of allKeys) {
             const isKeyToPreserve = keysToPreserve.includes(key);
             const isDefaultKey = key in defaultKeyStates;
             // If the key is being removed or reset to default:
@@ -330,19 +330,19 @@ function clear(keysToPreserve = []) {
                 }
             }
             if (isKeyToPreserve || isDefaultKey) {
-                return;
+                continue;
             }
             // 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
-        Object.entries(keyValuesToResetIndividually).forEach(([key, value]) => {
+        for (const [key, value] of Object.entries(keyValuesToResetIndividually)) {
             updatePromises.push(OnyxUtils_1.default.scheduleSubscriberUpdate(key, value));
-        });
-        Object.entries(keyValuesToResetAsCollection).forEach(([key, value]) => {
+        }
+        for (const [key, value] of Object.entries(keyValuesToResetAsCollection)) {
             updatePromises.push(OnyxUtils_1.default.scheduleNotifyCollectionSubscribers(key, value));
-        });
+        }
         const defaultKeyValuePairs = Object.entries(Object.keys(defaultKeyStates)
             .filter((key) => !keysToPreserve.includes(key))
             .reduce((obj, key) => {
@@ -351,7 +351,8 @@ function clear(keysToPreserve = []) {
             return obj;
         }, {}));
         // Remove only the items that we want cleared from storage, and reset others to default
-        keysToBeClearedFromStorage.forEach((key) => OnyxCache_1.default.drop(key));
+        for (const key of keysToBeClearedFromStorage)
+            OnyxCache_1.default.drop(key);
         return storage_1.default.removeItems(keysToBeClearedFromStorage)
             .then(() => OnyxConnectionManager_1.default.refreshSessionID())
             .then(() => storage_1.default.multiSet(defaultKeyValuePairs))
@@ -371,7 +372,7 @@ function clear(keysToPreserve = []) {
  */
 function update(data) {
     // First, validate the Onyx object is in the format we expect
-    data.forEach(({ onyxMethod, key, value }) => {
+    for (const { onyxMethod, key, value } of data) {
         if (!Object.values(OnyxUtils_1.default.METHOD).includes(onyxMethod)) {
             throw new Error(`Invalid onyxMethod ${onyxMethod} in Onyx update.`);
         }
@@ -384,7 +385,7 @@ function update(data) {
         else if (onyxMethod !== OnyxUtils_1.default.METHOD.CLEAR && typeof key !== 'string') {
             throw new Error(`Invalid ${typeof key} key provided in Onyx update. Onyx key must be of type string.`);
         }
-    });
+    }
     // The queue of operations within a single `update` call in the format of <item key - list of operations updating the item>.
     // This allows us to batch the operations per item and merge them into one operation in the order they were requested.
     const updateQueue = {};
@@ -408,7 +409,7 @@ function update(data) {
     };
     const promises = [];
     let clearPromise = Promise.resolve();
-    data.forEach(({ onyxMethod, key, value }) => {
+    for (const { onyxMethod, key, value } of data) {
         const handlers = {
             [OnyxUtils_1.default.METHOD.SET]: enqueueSetOperation,
             [OnyxUtils_1.default.METHOD.MERGE]: enqueueMergeOperation,
@@ -422,26 +423,30 @@ function update(data) {
                 const collectionKeys = Object.keys(collection);
                 if (OnyxUtils_1.default.doAllCollectionItemsBelongToSameParent(key, collectionKeys)) {
                     const mergedCollection = collection;
-                    collectionKeys.forEach((collectionKey) => enqueueMergeOperation(collectionKey, mergedCollection[collectionKey]));
+                    for (const collectionKey of collectionKeys)
+                        enqueueMergeOperation(collectionKey, mergedCollection[collectionKey]);
                 }
             },
             [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.MULTI_SET]: (k, v) => {
+                for (const [entryKey, entryValue] of Object.entries(v))
+                    enqueueSetOperation(entryKey, entryValue);
+            },
             [OnyxUtils_1.default.METHOD.CLEAR]: () => {
                 clearPromise = clear();
             },
         };
         handlers[onyxMethod](key, value);
-    });
+    }
     // Group all the collection-related keys and update each collection in a single `mergeCollection` call.
     // This is needed to prevent multiple `mergeCollection` calls for the same collection and `merge` calls for the individual items of the said collection.
     // This way, we ensure there is no race condition in the queued updates of the same key.
-    OnyxUtils_1.default.getCollectionKeys().forEach((collectionKey) => {
+    for (const collectionKey of OnyxUtils_1.default.getCollectionKeys()) {
         const collectionItemKeys = Object.keys(updateQueue).filter((key) => OnyxUtils_1.default.isKeyMatch(collectionKey, key));
         if (collectionItemKeys.length <= 1) {
             // If there are no items of this collection in the updateQueue, we should skip it.
             // If there is only one item, we should update it individually, therefore retain it in the updateQueue.
-            return;
+            continue;
         }
         const batchedCollectionUpdates = collectionItemKeys.reduce((queue, key) => {
             const operations = updateQueue[key];
@@ -477,17 +482,17 @@ function update(data) {
         if (!utils_1.default.isEmptyObject(batchedCollectionUpdates.set)) {
             promises.push(() => OnyxUtils_1.default.partialSetCollection({ collectionKey, collection: batchedCollectionUpdates.set }));
         }
-    });
-    Object.entries(updateQueue).forEach(([key, operations]) => {
+    }
+    for (const [key, operations] of Object.entries(updateQueue)) {
         if (operations[0] === null) {
             const batchedChanges = OnyxUtils_1.default.mergeChanges(operations).result;
             promises.push(() => set(key, batchedChanges));
-            return;
+            continue;
         }
-        operations.forEach((operation) => {
+        for (const operation of operations) {
             promises.push(() => merge(key, operation));
-        });
-    });
+        }
+    }
     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);
@@ -526,7 +531,6 @@ const Onyx = {
 };
 function applyDecorators() {
     // We are reassigning the functions directly so that internal function calls are also decorated
-    /* eslint-disable rulesdir/prefer-actions-set-data */
     // @ts-expect-error Reassign
     connect = (0, metrics_1.default)(connect, 'Onyx.connect');
     // @ts-expect-error Reassign
@@ -543,6 +547,5 @@ function applyDecorators() {
     update = (0, metrics_1.default)(update, 'Onyx.update');
     // @ts-expect-error Reassign
     clear = (0, metrics_1.default)(clear, 'Onyx.clear');
-    /* eslint-enable rulesdir/prefer-actions-set-data */
 }
 exports.default = Onyx;

package/dist/OnyxCache.js

@@ -179,7 +179,7 @@ class OnyxCache {
             shouldRemoveNestedNulls: true,
             objectRemovalMode: 'replace',
         }).result);
-        Object.entries(data).forEach(([key, value]) => {
+        for (const [key, value] of Object.entries(data)) {
             this.addKey(key);
             this.addToAccessedKeys(key);
             const collectionKey = this.getCollectionKey(key);
@@ -200,7 +200,7 @@ class OnyxCache {
                     this.collectionData[collectionKey][key] = this.storageMap[key];
                 }
             }
-        });
+        }
     }
     /**
      * Check whether the given task is already running
@@ -332,14 +332,14 @@ class OnyxCache {
      */
     addEvictableKeysToRecentlyAccessedList(isCollectionKeyFn, getAllKeysFn) {
         return getAllKeysFn().then((keys) => {
-            this.evictionAllowList.forEach((evictableKey) => {
-                keys.forEach((key) => {
+            for (const evictableKey of this.evictionAllowList) {
+                for (const key of keys) {
                     if (!this.isKeyMatch(evictableKey, key)) {
-                        return;
+                        continue;
                     }
                     this.addLastAccessedKey(key, isCollectionKeyFn(key));
-                });
-            });
+                }
+            }
         });
     }
     /**
@@ -359,12 +359,12 @@ class OnyxCache {
     setCollectionKeys(collectionKeys) {
         this.collectionKeys = collectionKeys;
         // Initialize collection data for existing collection keys
-        collectionKeys.forEach((collectionKey) => {
+        for (const collectionKey of collectionKeys) {
             if (this.collectionData[collectionKey]) {
-                return;
+                continue;
             }
             this.collectionData[collectionKey] = {};
-        });
+        }
     }
     /**
      * Check if a key is a collection key

package/dist/OnyxConnectionManager.js

@@ -81,14 +81,17 @@ class OnyxConnectionManager {
      */
     fireCallbacks(connectionID) {
         const connection = this.connectionsMap.get(connectionID);
-        connection === null || connection === void 0 ? void 0 : connection.callbacks.forEach((callback) => {
+        if (!connection) {
+            return;
+        }
+        for (const callback of connection.callbacks.values()) {
             if (connection.waitForCollectionCallback) {
                 callback(connection.cachedCallbackValue, connection.cachedCallbackKey, connection.sourceValue);
             }
             else {
                 callback(connection.cachedCallbackValue, connection.cachedCallbackKey);
             }
-        });
+        }
     }
     /**
      * Connects to an Onyx key given the options passed and listens to its changes.
@@ -168,12 +171,12 @@ class OnyxConnectionManager {
      * Disconnect all subscribers from Onyx.
      */
     disconnectAll() {
-        this.connectionsMap.forEach((connectionMetadata, connectionID) => {
+        for (const [connectionID, connectionMetadata] of this.connectionsMap.entries()) {
             OnyxUtils_1.default.unsubscribeFromKey(connectionMetadata.subscriptionID);
-            connectionMetadata.callbacks.forEach((_, callbackID) => {
+            for (const callbackID of connectionMetadata.callbacks.keys()) {
                 this.removeFromEvictionBlockList({ id: connectionID, callbackID });
-            });
-        });
+            }
+        }
         this.connectionsMap.clear();
         // Clear snapshot cache when all connections are disconnected
         OnyxSnapshotCache_1.default.clear();

package/dist/OnyxUtils.js

@@ -37,7 +37,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.clearOnyxUtilsInternals = clearOnyxUtilsInternals;
-/* eslint-disable no-continue */
 const fast_equals_1 = require("fast-equals");
 const pick_1 = __importDefault(require("lodash/pick"));
 const underscore_1 = __importDefault(require("underscore"));
@@ -185,9 +184,9 @@ function maybeFlushBatchUpdates() {
             batchUpdatesQueue = [];
             batchUpdatesPromise = null;
             (0, batch_1.default)(() => {
-                updatesCopy.forEach((applyUpdates) => {
+                for (const applyUpdates of updatesCopy) {
                     applyUpdates();
-                });
+                }
             });
             resolve();
         }, 0);
@@ -265,11 +264,11 @@ function multiGet(keys) {
      *
      * These missingKeys will be later used to multiGet the data from the storage.
      */
-    keys.forEach((key) => {
+    for (const key of keys) {
         const cacheValue = OnyxCache_1.default.get(key);
         if (cacheValue) {
             dataMap.set(key, cacheValue);
-            return;
+            continue;
         }
         const pendingKey = `${OnyxCache_1.TASK.GET}:${key}`;
         if (OnyxCache_1.default.hasPendingTask(pendingKey)) {
@@ -279,13 +278,13 @@ function multiGet(keys) {
         else {
             missingKeys.push(key);
         }
-    });
+    }
     return (Promise.all(pendingTasks)
         // Wait for all the pending tasks to resolve and then add the data to the data map.
         .then((values) => {
-        values.forEach((value, index) => {
+        for (const [index, value] of values.entries()) {
             dataMap.set(pendingKeys[index], value);
-        });
+        }
         return Promise.resolve();
     })
         // Get the missing keys using multiGet from the storage.
@@ -302,13 +301,13 @@ function multiGet(keys) {
         }
         // temp object is used to merge the missing data into the cache
         const temp = {};
-        values.forEach(([key, value]) => {
+        for (const [key, value] of values) {
             if (skippableCollectionMemberIDs.size) {
                 try {
                     const [, collectionMemberID] = splitCollectionMemberKey(key);
                     if (skippableCollectionMemberIDs.has(collectionMemberID)) {
                         // The key is a skippable one, so we skip this iteration.
-                        return;
+                        continue;
                     }
                 }
                 catch (e) {
@@ -317,7 +316,7 @@ function multiGet(keys) {
             }
             dataMap.set(key, value);
             temp[key] = value;
-        });
+        }
         OnyxCache_1.default.merge(temp);
         return dataMap;
     }));
@@ -489,14 +488,14 @@ function getCachedCollection(collectionKey, collectionMemberKeys) {
         // If we have specific member keys, filter the collection
         if (collectionMemberKeys) {
             const filteredCollection = {};
-            collectionMemberKeys.forEach((key) => {
+            for (const key of collectionMemberKeys) {
                 if (collectionData[key] !== undefined) {
                     filteredCollection[key] = collectionData[key];
                 }
                 else if (OnyxCache_1.default.hasNullishStorageKey(key)) {
                     filteredCollection[key] = OnyxCache_1.default.get(key);
                 }
-            });
+            }
             return filteredCollection;
         }
         // Return a copy to avoid mutations affecting the cache
@@ -505,19 +504,19 @@ function getCachedCollection(collectionKey, collectionMemberKeys) {
     // Fallback to original implementation if collection data not available
     const collection = {};
     // forEach exists on both Set and Array
-    allKeys.forEach((key) => {
+    for (const key of allKeys) {
         // If we don't have collectionMemberKeys array then we have to check whether a key is a collection member key.
         // Because in that case the keys will be coming from `cache.getAllKeys()` and we need to filter out the keys that
         // are not part of the collection.
         if (!collectionMemberKeys && !isCollectionMemberKey(collectionKey, key)) {
-            return;
+            continue;
         }
         const cachedValue = OnyxCache_1.default.get(key);
         if (cachedValue === undefined && !OnyxCache_1.default.hasNullishStorageKey(key)) {
-            return;
+            continue;
         }
         collection[key] = OnyxCache_1.default.get(key);
-    });
+    }
     return collection;
 }
 /**
@@ -699,7 +698,7 @@ function addKeyToRecentlyAccessedIfNeeded(key) {
 function getCollectionDataAndSendAsObject(matchingKeys, mapping) {
     multiGet(matchingKeys).then((dataMap) => {
         const data = Object.fromEntries(dataMap.entries());
-        sendDataToConnection(mapping, data, undefined);
+        sendDataToConnection(mapping, data, mapping.key);
     });
 }
 /**
@@ -807,16 +806,16 @@ function hasPendingMergeForKey(key) {
  */
 function prepareKeyValuePairsForStorage(data, shouldRemoveNestedNulls, replaceNullPatches, isProcessingCollectionUpdate) {
     const pairs = [];
-    Object.entries(data).forEach(([key, value]) => {
+    for (const [key, value] of Object.entries(data)) {
         if (value === null) {
             remove(key, isProcessingCollectionUpdate);
-            return;
+            continue;
         }
         const valueWithoutNestedNullValues = (shouldRemoveNestedNulls !== null && shouldRemoveNestedNulls !== void 0 ? shouldRemoveNestedNulls : true) ? utils_1.default.removeNestedNullValues(value) : value;
         if (valueWithoutNestedNullValues !== undefined) {
             pairs.push([key, valueWithoutNestedNullValues, replaceNullPatches === null || replaceNullPatches === void 0 ? void 0 : replaceNullPatches[key]]);
         }
-    });
+    }
     return pairs;
 }
 /**
@@ -878,7 +877,8 @@ function initializeWithDefaultKeyStates() {
             shouldRemoveNestedNulls: true,
         }).result;
         OnyxCache_1.default.merge(merged !== null && merged !== void 0 ? merged : {});
-        Object.entries(merged !== null && merged !== void 0 ? merged : {}).forEach(([key, value]) => keyChanged(key, value));
+        for (const [key, value] of Object.entries(merged !== null && merged !== void 0 ? merged : {}))
+            keyChanged(key, value);
     });
 }
 /**
@@ -892,16 +892,16 @@ function isValidNonEmptyCollectionForMerge(collection) {
  */
 function doAllCollectionItemsBelongToSameParent(collectionKey, collectionKeys) {
     let hasCollectionKeyCheckFailed = false;
-    collectionKeys.forEach((dataKey) => {
+    for (const dataKey of collectionKeys) {
         if (isKeyMatch(collectionKey, dataKey)) {
-            return;
+            continue;
         }
         if (process.env.NODE_ENV === 'development') {
             throw new Error(`Provided collection doesn't have all its data belonging to the same parent. CollectionKey: ${collectionKey}, DataKey: ${dataKey}`);
         }
         hasCollectionKeyCheckFailed = true;
         Logger.logAlert(`Provided collection doesn't have all its data belonging to the same parent. CollectionKey: ${collectionKey}, DataKey: ${dataKey}`);
-    });
+    }
     return !hasCollectionKeyCheckFailed;
 }
 /**
@@ -947,12 +947,12 @@ function subscribeToKey(connectOptions) {
         }
         else {
             // Collection case - need to iterate through all keys to find matches (O(n))
-            keys.forEach((key) => {
+            for (const key of keys) {
                 if (!isKeyMatch(mapping.key, key)) {
-                    return;
+                    continue;
                 }
                 matchingKeys.push(key);
-            });
+            }
         }
         // If the key being connected to does not exist we initialize the value with null. For subscribers that connected
         // directly via connect() they will simply get a null value sent to them without any information about which key matched
@@ -961,9 +961,10 @@ function subscribeToKey(connectOptions) {
             if (mapping.key) {
                 OnyxCache_1.default.addNullishStorageKey(mapping.key);
             }
+            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, undefined);
+            sendDataToConnection(mapping, null, matchedKey);
             return;
         }
         // When using a callback subscriber we will either trigger the provided callback for each key we find or combine all values
@@ -977,9 +978,9 @@ function subscribeToKey(connectOptions) {
                 }
                 // We did not opt into using waitForCollectionCallback mode so the callback is called for every matching key.
                 multiGet(matchingKeys).then((values) => {
-                    values.forEach((val, key) => {
+                    for (const [key, val] of values.entries()) {
                         sendDataToConnection(mapping, val, key);
-                    });
+                    }
                 });
                 return;
             }
@@ -1011,42 +1012,42 @@ function updateSnapshots(data, mergeFn) {
         return [];
     const promises = [];
     const snapshotCollection = getCachedCollection(snapshotCollectionKey);
-    Object.entries(snapshotCollection).forEach(([snapshotEntryKey, snapshotEntryValue]) => {
+    for (const [snapshotEntryKey, snapshotEntryValue] of Object.entries(snapshotCollection)) {
         // Snapshots may not be present in cache. We don't know how to update them so we skip.
         if (!snapshotEntryValue) {
-            return;
+            continue;
         }
         let updatedData = {};
-        data.forEach(({ key, value }) => {
+        for (const { key, value } of data) {
             // snapshots are normal keys so we want to skip update if they are written to Onyx
             if (isCollectionMemberKey(snapshotCollectionKey, key)) {
-                return;
+                continue;
             }
             if (typeof snapshotEntryValue !== 'object' || !('data' in snapshotEntryValue)) {
-                return;
+                continue;
             }
             const snapshotData = snapshotEntryValue.data;
             if (!snapshotData || !snapshotData[key]) {
-                return;
+                continue;
             }
             if (Array.isArray(value) || Array.isArray(snapshotData[key])) {
                 updatedData[key] = value || [];
-                return;
+                continue;
             }
             if (value === null) {
                 updatedData[key] = value;
-                return;
+                continue;
             }
             const oldValue = updatedData[key] || {};
             const newValue = (0, pick_1.default)(value, Object.keys(snapshotData[key]));
             updatedData = Object.assign(Object.assign({}, updatedData), { [key]: Object.assign(oldValue, newValue) });
-        });
+        }
         // Skip the update if there's no data to be merged
         if (utils_1.default.isEmptyObject(updatedData)) {
-            return;
+            continue;
         }
         promises.push(() => mergeFn(snapshotEntryKey, { data: updatedData }));
-    });
+    }
     return promises;
 }
 /**
@@ -1200,18 +1201,19 @@ function setCollectionWithRetry({ collectionKey, collection }, retryAttempt) {
     resultCollectionKeys = Object.keys(resultCollection);
     return OnyxUtils.getAllKeys().then((persistedKeys) => {
         const mutableCollection = Object.assign({}, resultCollection);
-        persistedKeys.forEach((key) => {
+        for (const key of persistedKeys) {
             if (!key.startsWith(collectionKey)) {
-                return;
+                continue;
             }
             if (resultCollectionKeys.includes(key)) {
-                return;
+                continue;
             }
             mutableCollection[key] = null;
-        });
+        }
         const keyValuePairs = OnyxUtils.prepareKeyValuePairsForStorage(mutableCollection, true, undefined, true);
         const previousCollection = OnyxUtils.getCachedCollection(collectionKey);
-        keyValuePairs.forEach(([key, value]) => OnyxCache_1.default.set(key, value));
+        for (const [key, value] of keyValuePairs)
+            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))
@@ -1285,12 +1287,12 @@ function mergeCollectionWithPatches({ collectionKey, collection, mergeReplaceNul
             return obj;
         }, {});
         const newCollection = {};
-        keys.forEach((key) => {
+        for (const key of keys) {
             if (persistedKeys.has(key)) {
-                return;
+                continue;
             }
             newCollection[key] = resultCollection[key];
-        });
+        }
         // When (multi-)merging the values with the existing values in storage,
         // we don't want to remove nested null values from the data that we pass to the storage layer,
         // because the storage layer uses them to remove nested keys from storage natively.
@@ -1367,7 +1369,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);
-        keyValuePairs.forEach(([key, value]) => OnyxCache_1.default.set(key, value));
+        for (const [key, value] of keyValuePairs)
+            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))

package/dist/dependencies/PerformanceProxy/index.native.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const ModuleProxy_1 = require("../ModuleProxy");
 const PerformanceProxy = (0, ModuleProxy_1.createModuleProxy)(() => {
     try {
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
         return require('react-native-performance').default;
     }
     catch (_a) {

package/dist/logMessages.js

@@ -1,8 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const logMessages = {
-    incompatibleUpdateAlert: (key, operation, existingValueType, newValueType) => {
-        return `Warning: Trying to apply "${operation}" with ${newValueType !== null && newValueType !== void 0 ? newValueType : 'unknown'} type to ${existingValueType !== null && existingValueType !== void 0 ? existingValueType : 'unknown'} type in the key "${key}"`;
-    },
+    incompatibleUpdateAlert: (key, operation, existingValueType, newValueType) => `Warning: Trying to apply "${operation}" with ${newValueType !== null && newValueType !== void 0 ? newValueType : 'unknown'} type to ${existingValueType !== null && existingValueType !== void 0 ? existingValueType : 'unknown'} type in the key "${key}"`,
 };
 exports.default = logMessages;

package/dist/storage/InstanceSync/index.web.js

@@ -14,9 +14,9 @@ function raiseStorageSyncEvent(onyxKey) {
     global.localStorage.removeItem(SYNC_ONYX);
 }
 function raiseStorageSyncManyKeysEvent(onyxKeys) {
-    onyxKeys.forEach((onyxKey) => {
+    for (const onyxKey of onyxKeys) {
         raiseStorageSyncEvent(onyxKey);
-    });
+    }
 }
 let storage = NoopProvider_1.default;
 const InstanceSync = {

package/dist/storage/providers/MemoryOnlyProvider.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.setMockStore = exports.mockStore = exports.mockSet = void 0;
 const underscore_1 = __importDefault(require("underscore"));
 const utils_1 = __importDefault(require("../../utils"));
-// eslint-disable-next-line import/no-mutable-exports
 const storeInternal = {};
 exports.mockStore = storeInternal;
 const setInternal = (key, value) => {
@@ -70,14 +69,14 @@ const provider = {
      * This function also removes all nested null values from an object.
      */
     multiMerge(pairs) {
-        underscore_1.default.forEach(pairs, ([key, value]) => {
+        for (const [key, value] of pairs) {
             const existingValue = provider.store[key];
             const newValue = utils_1.default.fastMerge(existingValue, value, {
                 shouldRemoveNestedNulls: true,
                 objectRemovalMode: 'replace',
             }).result;
             set(key, newValue);
-        });
+        }
         return Promise.resolve();
     },
     /**

package/dist/storage/providers/NoopProvider.js

@@ -15,7 +15,7 @@ const provider = {
     /**
      * Get the value of a given key or return `null` if it's not available in memory
      */
-    getItem(key) {
+    getItem(_key) {
         return Promise.resolve(null);
     },
     /**

package/dist/types.d.ts

@@ -370,9 +370,7 @@ type GenericFunction = (...args: any[]) => any;
  * Represents a 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.
  */
-type MultiMergeReplaceNullPatches = {
-    [TKey in OnyxKey]: FastMergeReplaceNullPatch[];
-};
+type MultiMergeReplaceNullPatches = Record<OnyxKey, FastMergeReplaceNullPatch[]>;
 /**
  * Represents a combination of Merge and Set operations that should be executed in Onyx
  */

package/dist/utils.js

@@ -44,32 +44,32 @@ function mergeObject(target, source, options, metadata, basePath) {
     // If "shouldRemoveNestedNulls" is true, we want to remove null values from the merged object
     // and therefore we need to omit keys where either the source or target value is null.
     if (targetObject) {
-        Object.keys(targetObject).forEach((key) => {
+        for (const key of Object.keys(targetObject)) {
             const targetProperty = targetObject === null || targetObject === void 0 ? void 0 : targetObject[key];
             const sourceProperty = source === null || source === void 0 ? void 0 : source[key];
             // If "shouldRemoveNestedNulls" is true, we want to remove (nested) null values from the merged object.
             // If either the source or target value is null, we want to omit the key from the merged object.
             const shouldOmitNullishProperty = options.shouldRemoveNestedNulls && (targetProperty === null || sourceProperty === null);
             if (targetProperty === undefined || shouldOmitNullishProperty) {
-                return;
+                continue;
             }
             destination[key] = targetProperty;
-        });
+        }
     }
     // After copying over all keys from the target object, we want to merge the source object into the destination object.
-    Object.keys(source).forEach((key) => {
+    for (const key of Object.keys(source)) {
         let targetProperty = targetObject === null || targetObject === void 0 ? void 0 : targetObject[key];
         const sourceProperty = source === null || source === void 0 ? void 0 : source[key];
         // If "shouldRemoveNestedNulls" is true, we want to remove (nested) null values from the merged object.
         // If the source value is null, we want to omit the key from the merged object.
         const shouldOmitNullishProperty = options.shouldRemoveNestedNulls && sourceProperty === null;
         if (sourceProperty === undefined || shouldOmitNullishProperty) {
-            return;
+            continue;
         }
         // If the source value is not a mergable object, we need to set the key directly.
         if (!isMergeableObject(sourceProperty)) {
             destination[key] = sourceProperty;
-            return;
+            continue;
         }
         // If "shouldMarkRemovedObjects" is enabled and the previous merge change (targetProperty) is null,
         // it means we want to fully replace this object when merging the batched changes with the Onyx value.
@@ -88,10 +88,10 @@ function mergeObject(target, source, options, metadata, basePath) {
             const sourcePropertyWithoutMark = Object.assign({}, sourceProperty);
             delete sourcePropertyWithoutMark.ONYX_INTERNALS__REPLACE_OBJECT_MARK;
             destination[key] = sourcePropertyWithoutMark;
-            return;
+            continue;
         }
         destination[key] = fastMerge(targetProperty, sourceProperty, options, metadata, [...basePath, key]).result;
-    });
+    }
     return destination;
 }
 /** Checks whether the given object is an object and not null/undefined. */
@@ -119,7 +119,6 @@ function removeNestedNullValues(value) {
     for (const key in value) {
         const propertyValue = value[key];
         if (propertyValue === null || propertyValue === undefined) {
-            // eslint-disable-next-line no-continue
             continue;
         }
         if (typeof propertyValue === 'object' && !Array.isArray(propertyValue)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-onyx",
-  "version": "3.0.27",
+  "version": "3.0.29",
   "author": "Expensify, Inc.",
   "homepage": "https://expensify.com",
   "description": "State management for React Native",
@@ -54,7 +54,7 @@
   "devDependencies": {
     "@actions/core": "^1.10.1",
     "@jest/globals": "^29.7.0",
-    "@lwc/eslint-plugin-lwc": "^1.7.2",
+    "@lwc/eslint-plugin-lwc": "^3.3.0",
     "@ngneat/falso": "^7.3.0",
     "@react-native-community/eslint-config": "^3.2.0",
     "@react-native/babel-preset": "0.76.3",
@@ -68,16 +68,17 @@
     "@types/react-dom": "^18.2.18",
     "@types/react-native": "^0.70.0",
     "@types/underscore": "^1.11.15",
-    "@typescript-eslint/eslint-plugin": "^6.19.0",
-    "@typescript-eslint/parser": "^6.19.0",
+    "@typescript-eslint/eslint-plugin": "^8.51.0",
+    "@typescript-eslint/parser": "^8.51.0",
     "@vercel/ncc": "0.38.1",
     "date-fns": "^4.1.0",
-    "eslint": "^8.56.0",
-    "eslint-config-expensify": "^2.0.81",
-    "eslint-config-prettier": "^8.8.0",
-    "eslint-plugin-import": "^2.29.1",
-    "eslint-plugin-jsx-a11y": "^6.8.0",
-    "eslint-plugin-react": "^7.31.10",
+    "eslint": "^9.39.2",
+    "eslint-config-expensify": "^2.0.102",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-jsx-a11y": "^6.10.2",
+    "eslint-plugin-react": "^7.37.5",
     "fake-indexeddb": "^6.2.5",
     "idb-keyval": "^6.2.1",
     "jest": "^29.7.0",