react-native-onyx 1.0.56 → 1.0.58

package/dist/web.development.js

@@ -1,13 +1,13 @@
 (function webpackUniversalModuleDefinition(root, factory) {
 	if(typeof exports === 'object' && typeof module === 'object')
-		module.exports = factory(require("fast-equals"), require("lodash/get"), require("underscore"), require("localforage"), require("localforage-removeitems"), require("lodash/transform"), require("react"));
+		module.exports = factory(require("fast-equals"), require("underscore"), require("localforage"), require("localforage-removeitems"), require("lodash/transform"), require("react"));
 	else if(typeof define === 'function' && define.amd)
-		define(["fast-equals", "lodash/get", "underscore", "localforage", "localforage-removeitems", "lodash/transform", "react"], factory);
+		define(["fast-equals", "underscore", "localforage", "localforage-removeitems", "lodash/transform", "react"], factory);
 	else if(typeof exports === 'object')
-		exports["react-native-onyx/web"] = factory(require("fast-equals"), require("lodash/get"), require("underscore"), require("localforage"), require("localforage-removeitems"), require("lodash/transform"), require("react"));
+		exports["react-native-onyx/web"] = factory(require("fast-equals"), require("underscore"), require("localforage"), require("localforage-removeitems"), require("lodash/transform"), require("react"));
 	else
-		root["react-native-onyx/web"] = factory(root["fast-equals"], root["lodash/get"], root["underscore"], root["localforage"], root["localforage-removeitems"], root["lodash/transform"], root["react"]);
-})(self, (__WEBPACK_EXTERNAL_MODULE_fast_equals__, __WEBPACK_EXTERNAL_MODULE_lodash_get__, __WEBPACK_EXTERNAL_MODULE_underscore__, __WEBPACK_EXTERNAL_MODULE_localforage__, __WEBPACK_EXTERNAL_MODULE_localforage_removeitems__, __WEBPACK_EXTERNAL_MODULE_lodash_transform__, __WEBPACK_EXTERNAL_MODULE_react__) => {
+		root["react-native-onyx/web"] = factory(root["fast-equals"], root["underscore"], root["localforage"], root["localforage-removeitems"], root["lodash/transform"], root["react"]);
+})(self, (__WEBPACK_EXTERNAL_MODULE_fast_equals__, __WEBPACK_EXTERNAL_MODULE_underscore__, __WEBPACK_EXTERNAL_MODULE_localforage__, __WEBPACK_EXTERNAL_MODULE_localforage_removeitems__, __WEBPACK_EXTERNAL_MODULE_lodash_transform__, __WEBPACK_EXTERNAL_MODULE_react__) => {
 return /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
@@ -71,17 +71,15 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ });
 /* harmony import */ var fast_equals__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! fast-equals */ "fast-equals");
 /* harmony import */ var fast_equals__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(fast_equals__WEBPACK_IMPORTED_MODULE_0__);
-/* harmony import */ var lodash_get__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! lodash/get */ "lodash/get");
-/* harmony import */ var lodash_get__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(lodash_get__WEBPACK_IMPORTED_MODULE_1__);
-/* harmony import */ var underscore__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! underscore */ "underscore");
-/* harmony import */ var underscore__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(underscore__WEBPACK_IMPORTED_MODULE_2__);
-/* harmony import */ var _Logger__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./Logger */ "./lib/Logger.js");
-/* harmony import */ var _OnyxCache__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./OnyxCache */ "./lib/OnyxCache.js");
-/* harmony import */ var _Str__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./Str */ "./lib/Str.js");
-/* harmony import */ var _createDeferredTask__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./createDeferredTask */ "./lib/createDeferredTask.js");
-/* harmony import */ var _fastMerge__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./fastMerge */ "./lib/fastMerge.js");
-/* harmony import */ var _metrics_PerformanceUtils__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./metrics/PerformanceUtils */ "./lib/metrics/PerformanceUtils.js");
-/* harmony import */ var _storage__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./storage */ "./lib/storage/index.web.js");
+/* harmony import */ var underscore__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! underscore */ "underscore");
+/* harmony import */ var underscore__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(underscore__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _Logger__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./Logger */ "./lib/Logger.js");
+/* harmony import */ var _OnyxCache__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./OnyxCache */ "./lib/OnyxCache.js");
+/* harmony import */ var _Str__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./Str */ "./lib/Str.js");
+/* harmony import */ var _createDeferredTask__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./createDeferredTask */ "./lib/createDeferredTask.js");
+/* harmony import */ var _fastMerge__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./fastMerge */ "./lib/fastMerge.js");
+/* harmony import */ var _metrics_PerformanceUtils__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./metrics/PerformanceUtils */ "./lib/metrics/PerformanceUtils.js");
+/* harmony import */ var _storage__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./storage */ "./lib/storage/index.web.js");
 /* eslint-disable no-continue */
 
 
@@ -93,7 +91,6 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
-
 // Method constants
 const METHOD = {
   SET: 'set',
@@ -129,20 +126,16 @@ const evictionBlocklist = {};
 let defaultKeyStates = {};
 
 // Connections can be made before `Onyx.init`. They would wait for this task before resolving
-const deferredInitTask = (0,_createDeferredTask__WEBPACK_IMPORTED_MODULE_3__["default"])();
+const deferredInitTask = (0,_createDeferredTask__WEBPACK_IMPORTED_MODULE_2__["default"])();
 
 /**
- * Uses a selector string or function to return a simplified version of sourceData
+ * Uses a selector function to return a simplified version of sourceData
  * @param {Mixed} sourceData
- * @param {String|Function} selector
+ * @param {Function} selector Function that takes sourceData and returns a simplified version of it
  * @param {Object} [withOnyxInstanceState]
- *      If it's a string, the selector is passed to lodashGet on the sourceData
- *      If it's a function, it is passed the sourceData and it should return the simplified data
  * @returns {Mixed}
  */
-const getSubsetOfData = (sourceData, selector, withOnyxInstanceState) => underscore__WEBPACK_IMPORTED_MODULE_2___default().isFunction(selector) ?
-selector(sourceData, withOnyxInstanceState) :
-lodash_get__WEBPACK_IMPORTED_MODULE_1___default()(sourceData, selector);
+const getSubsetOfData = (sourceData, selector, withOnyxInstanceState) => selector(sourceData, withOnyxInstanceState);
 
 /**
  * Takes a collection of items (eg. {testKey_1:{a:'a'}, testKey_2:{b:'b'}})
@@ -153,7 +146,7 @@ lodash_get__WEBPACK_IMPORTED_MODULE_1___default()(sourceData, selector);
  * @param {Object} [withOnyxInstanceState]
  * @returns {Object}
  */
-const reduceCollectionWithSelector = (collection, selector, withOnyxInstanceState) => underscore__WEBPACK_IMPORTED_MODULE_2___default().reduce(collection, (finalCollection, item, key) => {
+const reduceCollectionWithSelector = (collection, selector, withOnyxInstanceState) => underscore__WEBPACK_IMPORTED_MODULE_1___default().reduce(collection, (finalCollection, item, key) => {
   // eslint-disable-next-line no-param-reassign
   finalCollection[key] = getSubsetOfData(item, selector, withOnyxInstanceState);
 
@@ -169,26 +162,26 @@ const reduceCollectionWithSelector = (collection, selector, withOnyxInstanceStat
  */
 function get(key) {
   // When we already have the value in cache - resolve right away
-  if (_OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].hasCacheForKey(key)) {
-    return Promise.resolve(_OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].getValue(key));
+  if (_OnyxCache__WEBPACK_IMPORTED_MODULE_3__["default"].hasCacheForKey(key)) {
+    return Promise.resolve(_OnyxCache__WEBPACK_IMPORTED_MODULE_3__["default"].getValue(key));
   }
 
   const taskName = `get:${key}`;
 
   // When a value retrieving task for this key is still running hook to it
-  if (_OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].hasPendingTask(taskName)) {
-    return _OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].getTaskPromise(taskName);
+  if (_OnyxCache__WEBPACK_IMPORTED_MODULE_3__["default"].hasPendingTask(taskName)) {
+    return _OnyxCache__WEBPACK_IMPORTED_MODULE_3__["default"].getTaskPromise(taskName);
   }
 
   // Otherwise retrieve the value from storage and capture a promise to aid concurrent usages
-  const promise = _storage__WEBPACK_IMPORTED_MODULE_5__["default"].getItem(key).
+  const promise = _storage__WEBPACK_IMPORTED_MODULE_4__["default"].getItem(key).
   then((val) => {
-    _OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].set(key, val);
+    _OnyxCache__WEBPACK_IMPORTED_MODULE_3__["default"].set(key, val);
     return val;
   }).
-  catch((err) => _Logger__WEBPACK_IMPORTED_MODULE_6__.logInfo(`Unable to get item from persistent storage. Key: ${key} Error: ${err}`));
+  catch((err) => _Logger__WEBPACK_IMPORTED_MODULE_5__.logInfo(`Unable to get item from persistent storage. Key: ${key} Error: ${err}`));
 
-  return _OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].captureTask(taskName, promise);
+  return _OnyxCache__WEBPACK_IMPORTED_MODULE_3__["default"].captureTask(taskName, promise);
 }
 
 /**
@@ -198,7 +191,7 @@ function get(key) {
  */
 function getAllKeys() {
   // When we've already read stored keys, resolve right away
-  const storedKeys = _OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].getAllKeys();
+  const storedKeys = _OnyxCache__WEBPACK_IMPORTED_MODULE_3__["default"].getAllKeys();
   if (storedKeys.length > 0) {
     return Promise.resolve(storedKeys);
   }
@@ -206,18 +199,18 @@ function getAllKeys() {
   const taskName = 'getAllKeys';
 
   // When a value retrieving task for all keys is still running hook to it
-  if (_OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].hasPendingTask(taskName)) {
-    return _OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].getTaskPromise(taskName);
+  if (_OnyxCache__WEBPACK_IMPORTED_MODULE_3__["default"].hasPendingTask(taskName)) {
+    return _OnyxCache__WEBPACK_IMPORTED_MODULE_3__["default"].getTaskPromise(taskName);
   }
 
   // Otherwise retrieve the keys from storage and capture a promise to aid concurrent usages
-  const promise = _storage__WEBPACK_IMPORTED_MODULE_5__["default"].getAllKeys().
+  const promise = _storage__WEBPACK_IMPORTED_MODULE_4__["default"].getAllKeys().
   then((keys) => {
-    underscore__WEBPACK_IMPORTED_MODULE_2___default().each(keys, (key) => _OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].addKey(key));
+    underscore__WEBPACK_IMPORTED_MODULE_1___default().each(keys, (key) => _OnyxCache__WEBPACK_IMPORTED_MODULE_3__["default"].addKey(key));
     return keys;
   });
 
-  return _OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].captureTask(taskName, promise);
+  return _OnyxCache__WEBPACK_IMPORTED_MODULE_3__["default"].captureTask(taskName, promise);
 }
 
 /**
@@ -229,7 +222,7 @@ function getAllKeys() {
  * @returns {Boolean}
  */
 function isCollectionKey(key) {
-  return underscore__WEBPACK_IMPORTED_MODULE_2___default().contains(underscore__WEBPACK_IMPORTED_MODULE_2___default().values(onyxKeys.COLLECTION), key);
+  return underscore__WEBPACK_IMPORTED_MODULE_1___default().contains(underscore__WEBPACK_IMPORTED_MODULE_1___default().values(onyxKeys.COLLECTION), key);
 }
 
 /**
@@ -238,7 +231,7 @@ function isCollectionKey(key) {
  * @returns {Boolean}
  */
 function isCollectionMemberKey(collectionKey, key) {
-  return _Str__WEBPACK_IMPORTED_MODULE_7__.startsWith(key, collectionKey) && key.length > collectionKey.length;
+  return _Str__WEBPACK_IMPORTED_MODULE_6__.startsWith(key, collectionKey) && key.length > collectionKey.length;
 }
 
 /**
@@ -252,7 +245,7 @@ function isCollectionMemberKey(collectionKey, key) {
  */
 function isKeyMatch(configKey, key) {
   return isCollectionKey(configKey) ?
-  _Str__WEBPACK_IMPORTED_MODULE_7__.startsWith(key, configKey) :
+  _Str__WEBPACK_IMPORTED_MODULE_6__.startsWith(key, configKey) :
   configKey === key;
 }
 
@@ -265,7 +258,7 @@ function isKeyMatch(configKey, key) {
  * @returns {Boolean}
  */
 function isSafeEvictionKey(testKey) {
-  return underscore__WEBPACK_IMPORTED_MODULE_2___default().some(evictionAllowList, (key) => isKeyMatch(key, testKey));
+  return underscore__WEBPACK_IMPORTED_MODULE_1___default().some(evictionAllowList, (key) => isKeyMatch(key, testKey));
 }
 
 /**
@@ -277,13 +270,13 @@ function isSafeEvictionKey(testKey) {
  * @returns {Mixed}
  */
 function tryGetCachedValue(key) {let mapping = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  let val = _OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].getValue(key);
+  let val = _OnyxCache__WEBPACK_IMPORTED_MODULE_3__["default"].getValue(key);
 
   if (isCollectionKey(key)) {
-    const allKeys = _OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].getAllKeys();
-    const matchingKeys = underscore__WEBPACK_IMPORTED_MODULE_2___default().filter(allKeys, (k) => k.startsWith(key));
-    const values = underscore__WEBPACK_IMPORTED_MODULE_2___default().reduce(matchingKeys, (finalObject, matchedKey) => {
-      const cachedValue = _OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].getValue(matchedKey);
+    const allKeys = _OnyxCache__WEBPACK_IMPORTED_MODULE_3__["default"].getAllKeys();
+    const matchingKeys = underscore__WEBPACK_IMPORTED_MODULE_1___default().filter(allKeys, (k) => k.startsWith(key));
+    const values = underscore__WEBPACK_IMPORTED_MODULE_1___default().reduce(matchingKeys, (finalObject, matchedKey) => {
+      const cachedValue = _OnyxCache__WEBPACK_IMPORTED_MODULE_3__["default"].getValue(matchedKey);
       if (cachedValue) {
         // This is permissible because we're in the process of constructing the final object in a reduce function.
         // eslint-disable-next-line no-param-reassign
@@ -291,7 +284,7 @@ function tryGetCachedValue(key) {let mapping = arguments.length > 1 && arguments
       }
       return finalObject;
     }, {});
-    if (underscore__WEBPACK_IMPORTED_MODULE_2___default().isEmpty(values)) {
+    if (underscore__WEBPACK_IMPORTED_MODULE_1___default().isEmpty(values)) {
       return;
     }
     val = values;
@@ -315,7 +308,7 @@ function tryGetCachedValue(key) {let mapping = arguments.length > 1 && arguments
  * @param {String} key
  */
 function removeLastAccessedKey(key) {
-  recentlyAccessedKeys = underscore__WEBPACK_IMPORTED_MODULE_2___default().without(recentlyAccessedKeys, key);
+  recentlyAccessedKeys = underscore__WEBPACK_IMPORTED_MODULE_1___default().without(recentlyAccessedKeys, key);
 }
 
 /**
@@ -345,7 +338,7 @@ function addLastAccessedKey(key) {
  * @param {Number} connectionID
  */
 function removeFromEvictionBlockList(key, connectionID) {
-  evictionBlocklist[key] = underscore__WEBPACK_IMPORTED_MODULE_2___default().without(evictionBlocklist[key] || [], connectionID);
+  evictionBlocklist[key] = underscore__WEBPACK_IMPORTED_MODULE_1___default().without(evictionBlocklist[key] || [], connectionID);
 
   // Remove the key if there are no more subscribers
   if (evictionBlocklist[key].length === 0) {
@@ -382,8 +375,8 @@ function addToEvictionBlockList(key, connectionID) {
 function addAllSafeEvictionKeysToRecentlyAccessedList() {
   return getAllKeys().
   then((keys) => {
-    underscore__WEBPACK_IMPORTED_MODULE_2___default().each(evictionAllowList, (safeEvictionKey) => {
-      underscore__WEBPACK_IMPORTED_MODULE_2___default().each(keys, (key) => {
+    underscore__WEBPACK_IMPORTED_MODULE_1___default().each(evictionAllowList, (safeEvictionKey) => {
+      underscore__WEBPACK_IMPORTED_MODULE_1___default().each(keys, (key) => {
         if (!isKeyMatch(safeEvictionKey, key)) {
           return;
         }
@@ -399,12 +392,12 @@ function addAllSafeEvictionKeysToRecentlyAccessedList() {
  * @returns {Object}
  */
 function getCachedCollection(collectionKey) {
-  const collectionMemberKeys = underscore__WEBPACK_IMPORTED_MODULE_2___default().filter(_OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].getAllKeys(),
+  const collectionMemberKeys = underscore__WEBPACK_IMPORTED_MODULE_1___default().filter(_OnyxCache__WEBPACK_IMPORTED_MODULE_3__["default"].getAllKeys(),
   (storedKey) => isCollectionMemberKey(collectionKey, storedKey));
 
 
-  return underscore__WEBPACK_IMPORTED_MODULE_2___default().reduce(collectionMemberKeys, (prev, curr) => {
-    const cachedValue = _OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].getValue(curr);
+  return underscore__WEBPACK_IMPORTED_MODULE_1___default().reduce(collectionMemberKeys, (prev, curr) => {
+    const cachedValue = _OnyxCache__WEBPACK_IMPORTED_MODULE_3__["default"].getValue(curr);
     if (!cachedValue) {
       return prev;
     }
@@ -426,7 +419,7 @@ function keysChanged(collectionKey, partialCollection) {
   // We are iterating over all subscribers similar to keyChanged(). However, we are looking for subscribers who are subscribing to either a collection key or
   // individual collection key member for the collection that is being updated. It is important to note that the collection parameter cane be a PARTIAL collection
   // and does not represent all of the combined keys and values for a collection key. It is just the "new" data that was merged in via mergeCollection().
-  const stateMappingKeys = underscore__WEBPACK_IMPORTED_MODULE_2___default().keys(callbackToStateMapping);
+  const stateMappingKeys = underscore__WEBPACK_IMPORTED_MODULE_1___default().keys(callbackToStateMapping);
   for (let i = 0; i < stateMappingKeys.length; i++) {
     const subscriber = callbackToStateMapping[stateMappingKeys[i]];
     if (!subscriber) {
@@ -434,7 +427,7 @@ function keysChanged(collectionKey, partialCollection) {
     }
 
     // Skip iteration if we do not have a collection key or a collection member key on this subscriber
-    if (!_Str__WEBPACK_IMPORTED_MODULE_7__.startsWith(subscriber.key, collectionKey)) {
+    if (!_Str__WEBPACK_IMPORTED_MODULE_6__.startsWith(subscriber.key, collectionKey)) {
       continue;
     }
 
@@ -453,7 +446,7 @@ function keysChanged(collectionKey, partialCollection) {
     const cachedCollection = getCachedCollection(collectionKey);
 
     // Regular Onyx.connect() subscriber found.
-    if (underscore__WEBPACK_IMPORTED_MODULE_2___default().isFunction(subscriber.callback)) {
+    if (underscore__WEBPACK_IMPORTED_MODULE_1___default().isFunction(subscriber.callback)) {
       // If they are subscribed to the collection key and using waitForCollectionCallback then we'll
       // send the whole cached collection.
       if (isSubscribedToCollectionKey) {
@@ -464,7 +457,7 @@ function keysChanged(collectionKey, partialCollection) {
 
         // If they are not using waitForCollectionCallback then we notify the subscriber with
         // the new merged data but only for any keys in the partial collection.
-        const dataKeys = underscore__WEBPACK_IMPORTED_MODULE_2___default().keys(partialCollection);
+        const dataKeys = underscore__WEBPACK_IMPORTED_MODULE_1___default().keys(partialCollection);
         for (let j = 0; j < dataKeys.length; j++) {
           const dataKey = dataKeys[j];
           subscriber.callback(cachedCollection[dataKey], dataKey);
@@ -505,14 +498,14 @@ function keysChanged(collectionKey, partialCollection) {
         }
 
         subscriber.withOnyxInstance.setState((prevState) => {
-          const finalCollection = underscore__WEBPACK_IMPORTED_MODULE_2___default().clone(prevState[subscriber.statePropertyName] || {});
-          const dataKeys = underscore__WEBPACK_IMPORTED_MODULE_2___default().keys(partialCollection);
+          const finalCollection = underscore__WEBPACK_IMPORTED_MODULE_1___default().clone(prevState[subscriber.statePropertyName] || {});
+          const dataKeys = underscore__WEBPACK_IMPORTED_MODULE_1___default().keys(partialCollection);
           for (let j = 0; j < dataKeys.length; j++) {
             const dataKey = dataKeys[j];
             finalCollection[dataKey] = cachedCollection[dataKey];
           }
 
-          _metrics_PerformanceUtils__WEBPACK_IMPORTED_MODULE_8__.logSetStateCall(subscriber, prevState[subscriber.statePropertyName], finalCollection, 'keysChanged', collectionKey);
+          _metrics_PerformanceUtils__WEBPACK_IMPORTED_MODULE_7__.logSetStateCall(subscriber, prevState[subscriber.statePropertyName], finalCollection, 'keysChanged', collectionKey);
           return {
             [subscriber.statePropertyName]: finalCollection
           };
@@ -525,7 +518,7 @@ function keysChanged(collectionKey, partialCollection) {
         // However, we only want to update this subscriber if the partial data contains a change.
         // Otherwise, we would update them with a value they already have and trigger an unnecessary re-render.
         const dataFromCollection = partialCollection[subscriber.key];
-        if (underscore__WEBPACK_IMPORTED_MODULE_2___default().isUndefined(dataFromCollection)) {
+        if (underscore__WEBPACK_IMPORTED_MODULE_1___default().isUndefined(dataFromCollection)) {
           continue;
         }
 
@@ -537,7 +530,7 @@ function keysChanged(collectionKey, partialCollection) {
             const prevData = prevState[subscriber.statePropertyName];
             const newData = getSubsetOfData(cachedCollection[subscriber.key], subscriber.selector, subscriber.withOnyxInstance.state);
             if (!(0,fast_equals__WEBPACK_IMPORTED_MODULE_0__.deepEqual)(prevData, newData)) {
-              _metrics_PerformanceUtils__WEBPACK_IMPORTED_MODULE_8__.logSetStateCall(subscriber, prevData, newData, 'keysChanged', collectionKey);
+              _metrics_PerformanceUtils__WEBPACK_IMPORTED_MODULE_7__.logSetStateCall(subscriber, prevData, newData, 'keysChanged', collectionKey);
               return {
                 [subscriber.statePropertyName]: newData
               };
@@ -555,7 +548,7 @@ function keysChanged(collectionKey, partialCollection) {
             return null;
           }
 
-          _metrics_PerformanceUtils__WEBPACK_IMPORTED_MODULE_8__.logSetStateCall(subscriber, previousData, data, 'keysChanged', collectionKey);
+          _metrics_PerformanceUtils__WEBPACK_IMPORTED_MODULE_7__.logSetStateCall(subscriber, previousData, data, 'keysChanged', collectionKey);
           return {
             [subscriber.statePropertyName]: data
           };
@@ -578,7 +571,7 @@ function keysChanged(collectionKey, partialCollection) {
  */
 function keyChanged(key, data, canUpdateSubscriber) {
   // Add or remove this key from the recentlyAccessedKeys lists
-  if (!underscore__WEBPACK_IMPORTED_MODULE_2___default().isNull(data)) {
+  if (!underscore__WEBPACK_IMPORTED_MODULE_1___default().isNull(data)) {
     addLastAccessedKey(key);
   } else {
     removeLastAccessedKey(key);
@@ -587,15 +580,15 @@ function keyChanged(key, data, canUpdateSubscriber) {
   // We are iterating over all subscribers to see if they are interested in the key that has just changed. If the subscriber's  key is a collection key then we will
   // notify them if the key that changed is a collection member. Or if it is a regular key notify them when there is an exact match. Depending on whether the subscriber
   // was connected via withOnyx we will call setState() directly on the withOnyx instance. If it is a regular connection we will pass the data to the provided callback.
-  const stateMappingKeys = underscore__WEBPACK_IMPORTED_MODULE_2___default().keys(callbackToStateMapping);
+  const stateMappingKeys = underscore__WEBPACK_IMPORTED_MODULE_1___default().keys(callbackToStateMapping);
   for (let i = 0; i < stateMappingKeys.length; i++) {
     const subscriber = callbackToStateMapping[stateMappingKeys[i]];
-    if (!subscriber || !isKeyMatch(subscriber.key, key) || underscore__WEBPACK_IMPORTED_MODULE_2___default().isFunction(canUpdateSubscriber) && !canUpdateSubscriber(subscriber)) {
+    if (!subscriber || !isKeyMatch(subscriber.key, key) || underscore__WEBPACK_IMPORTED_MODULE_1___default().isFunction(canUpdateSubscriber) && !canUpdateSubscriber(subscriber)) {
       continue;
     }
 
     // Subscriber is a regular call to connect() and provided a callback
-    if (underscore__WEBPACK_IMPORTED_MODULE_2___default().isFunction(subscriber.callback)) {
+    if (underscore__WEBPACK_IMPORTED_MODULE_1___default().isFunction(subscriber.callback)) {
       if (isCollectionKey(subscriber.key) && subscriber.waitForCollectionCallback) {
         const cachedCollection = getCachedCollection(subscriber.key);
         cachedCollection[key] = data;
@@ -624,7 +617,7 @@ function keyChanged(key, data, canUpdateSubscriber) {
               ...newData
             };
             if (!(0,fast_equals__WEBPACK_IMPORTED_MODULE_0__.deepEqual)(prevData, prevDataWithNewData)) {
-              _metrics_PerformanceUtils__WEBPACK_IMPORTED_MODULE_8__.logSetStateCall(subscriber, prevData, newData, 'keyChanged', key);
+              _metrics_PerformanceUtils__WEBPACK_IMPORTED_MODULE_7__.logSetStateCall(subscriber, prevData, newData, 'keyChanged', key);
               return {
                 [subscriber.statePropertyName]: prevDataWithNewData
               };
@@ -640,7 +633,7 @@ function keyChanged(key, data, canUpdateSubscriber) {
             ...collection,
             [key]: data
           };
-          _metrics_PerformanceUtils__WEBPACK_IMPORTED_MODULE_8__.logSetStateCall(subscriber, collection, newCollection, 'keyChanged', key);
+          _metrics_PerformanceUtils__WEBPACK_IMPORTED_MODULE_7__.logSetStateCall(subscriber, collection, newCollection, 'keyChanged', key);
           return {
             [subscriber.statePropertyName]: newCollection
           };
@@ -671,7 +664,7 @@ function keyChanged(key, data, canUpdateSubscriber) {
           return null;
         }
 
-        _metrics_PerformanceUtils__WEBPACK_IMPORTED_MODULE_8__.logSetStateCall(subscriber, previousData, data, 'keyChanged', key);
+        _metrics_PerformanceUtils__WEBPACK_IMPORTED_MODULE_7__.logSetStateCall(subscriber, previousData, data, 'keyChanged', key);
         return {
           [subscriber.statePropertyName]: data
         };
@@ -717,12 +710,12 @@ function sendDataToConnection(mapping, val, matchedKey) {
       }
     }
 
-    _metrics_PerformanceUtils__WEBPACK_IMPORTED_MODULE_8__.logSetStateCall(mapping, null, newData, 'sendDataToConnection');
+    _metrics_PerformanceUtils__WEBPACK_IMPORTED_MODULE_7__.logSetStateCall(mapping, null, newData, 'sendDataToConnection');
     mapping.withOnyxInstance.setWithOnyxState(mapping.statePropertyName, newData);
     return;
   }
 
-  if (underscore__WEBPACK_IMPORTED_MODULE_2___default().isFunction(mapping.callback)) {
+  if (underscore__WEBPACK_IMPORTED_MODULE_1___default().isFunction(mapping.callback)) {
     mapping.callback(val, matchedKey);
   }
 }
@@ -740,11 +733,11 @@ function addKeyToRecentlyAccessedIfNeeded(mapping) {
   }
 
   // Try to free some cache whenever we connect to a safe eviction key
-  _OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].removeLeastRecentlyUsedKeys();
+  _OnyxCache__WEBPACK_IMPORTED_MODULE_3__["default"].removeLeastRecentlyUsedKeys();
 
   if (mapping.withOnyxInstance && !isCollectionKey(mapping.key)) {
     // All React components subscribing to a key flagged as a safe eviction key must implement the canEvict property.
-    if (underscore__WEBPACK_IMPORTED_MODULE_2___default().isUndefined(mapping.canEvict)) {
+    if (underscore__WEBPACK_IMPORTED_MODULE_1___default().isUndefined(mapping.canEvict)) {
       throw new Error(
       `Cannot subscribe to safe eviction key '${mapping.key}' without providing a canEvict value.`);
 
@@ -762,8 +755,8 @@ function addKeyToRecentlyAccessedIfNeeded(mapping) {
  * @param {Object} mapping
  */
 function getCollectionDataAndSendAsObject(matchingKeys, mapping) {
-  Promise.all(underscore__WEBPACK_IMPORTED_MODULE_2___default().map(matchingKeys, (key) => get(key))).
-  then((values) => underscore__WEBPACK_IMPORTED_MODULE_2___default().reduce(values, (finalObject, value, i) => {
+  Promise.all(underscore__WEBPACK_IMPORTED_MODULE_1___default().map(matchingKeys, (key) => get(key))).
+  then((values) => underscore__WEBPACK_IMPORTED_MODULE_1___default().reduce(values, (finalObject, value, i) => {
     // eslint-disable-next-line no-param-reassign
     finalObject[matchingKeys[i]] = value;
     return finalObject;
@@ -790,11 +783,10 @@ function getCollectionDataAndSendAsObject(matchingKeys, mapping) {
  * @param {Boolean} [mapping.initWithStoredValues] If set to false, then no data will be prefilled into the
  *  component
  * @param {Boolean} [mapping.waitForCollectionCallback] If set to true, it will return the entire collection to the callback as a single object
- * @param {String|Function} [mapping.selector] THIS PARAM IS ONLY USED WITH withOnyx(). If included, this will be used to subscribe to a subset of an Onyx key's data.
- *       If the selector is a string, the selector is passed to lodashGet on the sourceData. If the selector is a function, the sourceData and withOnyx state are
- *       passed to the selector and should return the simplified data. Using this setting on `withOnyx` can have very positive performance benefits because the component
- *       will only re-render when the subset of data changes. Otherwise, any change of data on any property would normally cause the component to re-render (and that can
- *       be expensive from a performance standpoint).
+ * @param {Function} [mapping.selector] THIS PARAM IS ONLY USED WITH withOnyx(). If included, this will be used to subscribe to a subset of an Onyx key's data.
+ *       The sourceData and withOnyx state are passed to the selector and should return the simplified data. Using this setting on `withOnyx` can have very positive
+ *       performance benefits because the component will only re-render when the subset of data changes. Otherwise, any change of data on any property would normally
+ *       cause the component to re-render (and that can be expensive from a performance standpoint).
  * @returns {Number} an ID to use when calling disconnect
  */
 function connect(mapping) {
@@ -814,7 +806,7 @@ function connect(mapping) {
     // We search all the keys in storage to see if any are a "match" for the subscriber we are connecting so that we
     // can send data back to the subscriber. Note that multiple keys can match as a subscriber could either be
     // subscribed to a "collection key" or a single key.
-    const matchingKeys = underscore__WEBPACK_IMPORTED_MODULE_2___default().filter(keys, (key) => isKeyMatch(mapping.key, key));
+    const matchingKeys = underscore__WEBPACK_IMPORTED_MODULE_1___default().filter(keys, (key) => isKeyMatch(mapping.key, 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
@@ -828,7 +820,7 @@ function connect(mapping) {
     // When using a callback subscriber we will either trigger the provided callback for each key we find or combine all values
     // into an object and just make a single call. The latter behavior is enabled by providing a waitForCollectionCallback key
     // combined with a subscription to a collection key.
-    if (underscore__WEBPACK_IMPORTED_MODULE_2___default().isFunction(mapping.callback)) {
+    if (underscore__WEBPACK_IMPORTED_MODULE_1___default().isFunction(mapping.callback)) {
       if (isCollectionKey(mapping.key)) {
         if (mapping.waitForCollectionCallback) {
           getCollectionDataAndSendAsObject(matchingKeys, mapping);
@@ -929,9 +921,9 @@ function notifyCollectionSubscribersOnNextTick(key, value) {
  * @return {Promise}
  */
 function remove(key) {
-  _OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].drop(key);
+  _OnyxCache__WEBPACK_IMPORTED_MODULE_3__["default"].drop(key);
   notifySubscribersOnNextTick(key, null);
-  return _storage__WEBPACK_IMPORTED_MODULE_5__["default"].removeItem(key);
+  return _storage__WEBPACK_IMPORTED_MODULE_4__["default"].removeItem(key);
 }
 
 /**
@@ -946,23 +938,23 @@ function remove(key) {
  * @return {Promise}
  */
 function evictStorageAndRetry(error, onyxMethod) {for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {args[_key - 2] = arguments[_key];}
-  _Logger__WEBPACK_IMPORTED_MODULE_6__.logInfo(`Handled error: ${error}`);
+  _Logger__WEBPACK_IMPORTED_MODULE_5__.logInfo(`Handled error: ${error}`);
 
-  if (error && _Str__WEBPACK_IMPORTED_MODULE_7__.startsWith(error.message, 'Failed to execute \'put\' on \'IDBObjectStore\'')) {
-    _Logger__WEBPACK_IMPORTED_MODULE_6__.logAlert('Attempted to set invalid data set in Onyx. Please ensure all data is serializable.');
+  if (error && _Str__WEBPACK_IMPORTED_MODULE_6__.startsWith(error.message, 'Failed to execute \'put\' on \'IDBObjectStore\'')) {
+    _Logger__WEBPACK_IMPORTED_MODULE_5__.logAlert('Attempted to set invalid data set in Onyx. Please ensure all data is serializable.');
     throw error;
   }
 
   // Find the first key that we can remove that has no subscribers in our blocklist
-  const keyForRemoval = underscore__WEBPACK_IMPORTED_MODULE_2___default().find(recentlyAccessedKeys, (key) => !evictionBlocklist[key]);
+  const keyForRemoval = underscore__WEBPACK_IMPORTED_MODULE_1___default().find(recentlyAccessedKeys, (key) => !evictionBlocklist[key]);
 
   if (!keyForRemoval) {
-    _Logger__WEBPACK_IMPORTED_MODULE_6__.logAlert('Out of storage. But found no acceptable keys to remove.');
+    _Logger__WEBPACK_IMPORTED_MODULE_5__.logAlert('Out of storage. But found no acceptable keys to remove.');
     throw error;
   }
 
   // Remove the least recently viewed key that is not currently being accessed and retry.
-  _Logger__WEBPACK_IMPORTED_MODULE_6__.logInfo(`Out of storage. Evicting least recently accessed key (${keyForRemoval}) and retrying.`);
+  _Logger__WEBPACK_IMPORTED_MODULE_5__.logInfo(`Out of storage. Evicting least recently accessed key (${keyForRemoval}) and retrying.`);
   return remove(keyForRemoval).
   then(() => onyxMethod(...args));
 }
@@ -977,14 +969,14 @@ function evictStorageAndRetry(error, onyxMethod) {for (var _len = arguments.leng
  */
 function broadcastUpdate(key, value, hasChanged, method) {
   // Logging properties only since values could be sensitive things we don't want to log
-  _Logger__WEBPACK_IMPORTED_MODULE_6__.logInfo(`${method}() called for key: ${key}${underscore__WEBPACK_IMPORTED_MODULE_2___default().isObject(value) ? ` properties: ${underscore__WEBPACK_IMPORTED_MODULE_2___default().keys(value).join(',')}` : ''}`);
+  _Logger__WEBPACK_IMPORTED_MODULE_5__.logInfo(`${method}() called for key: ${key}${underscore__WEBPACK_IMPORTED_MODULE_1___default().isObject(value) ? ` properties: ${underscore__WEBPACK_IMPORTED_MODULE_1___default().keys(value).join(',')}` : ''}`);
 
   // Update subscribers if the cached value has changed, or when the subscriber specifically requires
   // all updates regardless of value changes (indicated by initWithStoredValues set to false).
   if (hasChanged) {
-    _OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].set(key, value);
+    _OnyxCache__WEBPACK_IMPORTED_MODULE_3__["default"].set(key, value);
   } else {
-    _OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].addToAccessedKeys(key);
+    _OnyxCache__WEBPACK_IMPORTED_MODULE_3__["default"].addToAccessedKeys(key);
   }
 
   notifySubscribersOnNextTick(key, value, (subscriber) => hasChanged || subscriber.initWithStoredValues === false);
@@ -999,6 +991,24 @@ function hasPendingMergeForKey(key) {
   return Boolean(mergeQueue[key]);
 }
 
+/**
+ * We generally want to remove top-level nullish values from objects written to disk and cache, because it decreases the amount of data stored in memory and on disk.
+ * On native, when merging an existing value with new changes, SQLite will use  JSON_PATCH, which removes top-level nullish values.
+ * To be consistent with the behaviour for merge, we'll also want to remove nullish values for "set" operations.
+ * On web, IndexedDB will keep the top-level keys along with a null value and this uses up storage and memory.
+ * This method will ensure that keys for null values are removed before an object is written to disk and cache so that all platforms are storing the data in the same efficient way.
+ * @private
+ * @param {*} value
+ * @returns {*}
+ */
+function removeNullObjectValues(value) {
+  if (underscore__WEBPACK_IMPORTED_MODULE_1___default().isArray(value) || !underscore__WEBPACK_IMPORTED_MODULE_1___default().isObject(value)) {
+    return value;
+  }
+
+  return underscore__WEBPACK_IMPORTED_MODULE_1___default().omit(value, (objectValue) => underscore__WEBPACK_IMPORTED_MODULE_1___default().isNull(objectValue));
+}
+
 /**
  * Write a value to our store with the given key
  *
@@ -1008,26 +1018,28 @@ function hasPendingMergeForKey(key) {
  * @returns {Promise}
  */
 function set(key, value) {
-  if (underscore__WEBPACK_IMPORTED_MODULE_2___default().isNull(value)) {
+  if (underscore__WEBPACK_IMPORTED_MODULE_1___default().isNull(value)) {
     return remove(key);
   }
 
   if (hasPendingMergeForKey(key)) {
-    _Logger__WEBPACK_IMPORTED_MODULE_6__.logAlert(`Onyx.set() called after Onyx.merge() for key: ${key}. It is recommended to use set() or merge() not both.`);
+    _Logger__WEBPACK_IMPORTED_MODULE_5__.logAlert(`Onyx.set() called after Onyx.merge() for key: ${key}. It is recommended to use set() or merge() not both.`);
   }
 
-  const hasChanged = _OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].hasValueChanged(key, value);
+  const valueWithNullRemoved = removeNullObjectValues(value);
+
+  const hasChanged = _OnyxCache__WEBPACK_IMPORTED_MODULE_3__["default"].hasValueChanged(key, valueWithNullRemoved);
 
   // This approach prioritizes fast UI changes without waiting for data to be stored in device storage.
-  broadcastUpdate(key, value, hasChanged, 'set');
+  broadcastUpdate(key, valueWithNullRemoved, hasChanged, 'set');
 
   // If the value has not changed, calling Storage.setItem() would be redundant and a waste of performance, so return early instead.
   if (!hasChanged) {
     return Promise.resolve();
   }
 
-  return _storage__WEBPACK_IMPORTED_MODULE_5__["default"].setItem(key, value).
-  catch((error) => evictStorageAndRetry(error, set, key, value));
+  return _storage__WEBPACK_IMPORTED_MODULE_4__["default"].setItem(key, valueWithNullRemoved).
+  catch((error) => evictStorageAndRetry(error, set, key, valueWithNullRemoved));
 }
 
 /**
@@ -1039,7 +1051,7 @@ function set(key, value) {
  * @return {Array} an array of key - value pairs <[key, value]>
  */
 function prepareKeyValuePairsForStorage(data) {
-  return underscore__WEBPACK_IMPORTED_MODULE_2___default().map(data, (value, key) => [key, value]);
+  return underscore__WEBPACK_IMPORTED_MODULE_1___default().map(data, (value, key) => [key, value]);
 }
 
 /**
@@ -1053,13 +1065,13 @@ function prepareKeyValuePairsForStorage(data) {
 function multiSet(data) {
   const keyValuePairs = prepareKeyValuePairsForStorage(data);
 
-  underscore__WEBPACK_IMPORTED_MODULE_2___default().each(data, (val, key) => {
+  underscore__WEBPACK_IMPORTED_MODULE_1___default().each(data, (val, key) => {
     // Update cache and optimistically inform subscribers on the next tick
-    _OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].set(key, val);
+    _OnyxCache__WEBPACK_IMPORTED_MODULE_3__["default"].set(key, val);
     notifySubscribersOnNextTick(key, val);
   });
 
-  return _storage__WEBPACK_IMPORTED_MODULE_5__["default"].multiSet(keyValuePairs).
+  return _storage__WEBPACK_IMPORTED_MODULE_4__["default"].multiSet(keyValuePairs).
   catch((error) => evictStorageAndRetry(error, multiSet, data));
 }
 
@@ -1072,17 +1084,17 @@ function multiSet(data) {
  * @returns {*}
  */
 function applyMerge(existingValue, changes) {
-  const lastChange = underscore__WEBPACK_IMPORTED_MODULE_2___default().last(changes);
+  const lastChange = underscore__WEBPACK_IMPORTED_MODULE_1___default().last(changes);
 
-  if (underscore__WEBPACK_IMPORTED_MODULE_2___default().isArray(existingValue) || underscore__WEBPACK_IMPORTED_MODULE_2___default().isArray(lastChange)) {
+  if (underscore__WEBPACK_IMPORTED_MODULE_1___default().isArray(existingValue) || underscore__WEBPACK_IMPORTED_MODULE_1___default().isArray(lastChange)) {
     return lastChange;
   }
 
-  if (underscore__WEBPACK_IMPORTED_MODULE_2___default().isObject(existingValue) || underscore__WEBPACK_IMPORTED_MODULE_2___default().every(changes, (underscore__WEBPACK_IMPORTED_MODULE_2___default().isObject))) {
+  if (underscore__WEBPACK_IMPORTED_MODULE_1___default().isObject(existingValue) || underscore__WEBPACK_IMPORTED_MODULE_1___default().every(changes, (underscore__WEBPACK_IMPORTED_MODULE_1___default().isObject))) {
     // Object values are merged one after the other
     // lodash adds a small overhead so we don't use it here
     // eslint-disable-next-line prefer-object-spread, rulesdir/prefer-underscore-method
-    return underscore__WEBPACK_IMPORTED_MODULE_2___default().reduce(changes, (modifiedData, change) => (0,_fastMerge__WEBPACK_IMPORTED_MODULE_9__["default"])(modifiedData, change),
+    return underscore__WEBPACK_IMPORTED_MODULE_1___default().reduce(changes, (modifiedData, change) => (0,_fastMerge__WEBPACK_IMPORTED_MODULE_8__["default"])(modifiedData, change),
     existingValue || {});
   }
 
@@ -1124,22 +1136,24 @@ function merge(key, changes) {
   then((existingValue) => {
     try {
       // We first only merge the changes, so we can provide these to the native implementation (SQLite uses only delta changes in "JSON_PATCH" to merge)
-      const batchedChanges = applyMerge(undefined, mergeQueue[key]);
+      let batchedChanges = applyMerge(undefined, mergeQueue[key]);
 
       // Clean up the write queue so we
       // don't apply these changes again
       delete mergeQueue[key];
 
       // After that we merge the batched changes with the existing value
-      let modifiedData = applyMerge(existingValue, [batchedChanges]);
-
-      // For objects, the key for null values needs to be removed from the object to ensure the value will get removed from storage completely.
-      // On native, SQLite will remove top-level keys that are null. To be consistent, we remove them on web too.
-      if (!underscore__WEBPACK_IMPORTED_MODULE_2___default().isArray(modifiedData) && underscore__WEBPACK_IMPORTED_MODULE_2___default().isObject(modifiedData)) {
-        modifiedData = underscore__WEBPACK_IMPORTED_MODULE_2___default().omit(modifiedData, (value) => underscore__WEBPACK_IMPORTED_MODULE_2___default().isNull(value));
+      const modifiedData = removeNullObjectValues(applyMerge(existingValue, [batchedChanges]));
+
+      // On native platforms we use SQLite which utilises JSON_PATCH to merge changes.
+      // JSON_PATCH generally removes top-level nullish values from the stored object.
+      // When there is no existing value though, SQLite will just insert the changes as a new value and thus the top-level nullish values won't be removed.
+      // Therefore we need to remove nullish values from the `batchedChanges` which are sent to the SQLite, if no existing value is present.
+      if (!existingValue) {
+        batchedChanges = removeNullObjectValues(batchedChanges);
       }
 
-      const hasChanged = _OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].hasValueChanged(key, modifiedData);
+      const hasChanged = _OnyxCache__WEBPACK_IMPORTED_MODULE_3__["default"].hasValueChanged(key, modifiedData);
 
       // This approach prioritizes fast UI changes without waiting for data to be stored in device storage.
       broadcastUpdate(key, modifiedData, hasChanged, 'merge');
@@ -1149,9 +1163,9 @@ function merge(key, changes) {
         return Promise.resolve();
       }
 
-      return _storage__WEBPACK_IMPORTED_MODULE_5__["default"].mergeItem(key, batchedChanges, modifiedData);
+      return _storage__WEBPACK_IMPORTED_MODULE_4__["default"].mergeItem(key, batchedChanges, modifiedData);
     } catch (error) {
-      _Logger__WEBPACK_IMPORTED_MODULE_6__.logAlert(`An error occurred while applying merge for key: ${key}, Error: ${error}`);
+      _Logger__WEBPACK_IMPORTED_MODULE_5__.logAlert(`An error occurred while applying merge for key: ${key}, Error: ${error}`);
     }
 
     return Promise.resolve();
@@ -1164,13 +1178,13 @@ function merge(key, changes) {
  * @returns {Promise}
  */
 function initializeWithDefaultKeyStates() {
-  return _storage__WEBPACK_IMPORTED_MODULE_5__["default"].multiGet(underscore__WEBPACK_IMPORTED_MODULE_2___default().keys(defaultKeyStates)).
+  return _storage__WEBPACK_IMPORTED_MODULE_4__["default"].multiGet(underscore__WEBPACK_IMPORTED_MODULE_1___default().keys(defaultKeyStates)).
   then((pairs) => {
-    const asObject = underscore__WEBPACK_IMPORTED_MODULE_2___default().object(pairs);
+    const asObject = underscore__WEBPACK_IMPORTED_MODULE_1___default().object(pairs);
 
-    const merged = (0,_fastMerge__WEBPACK_IMPORTED_MODULE_9__["default"])(asObject, defaultKeyStates);
-    _OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].merge(merged);
-    underscore__WEBPACK_IMPORTED_MODULE_2___default().each(merged, (val, key) => keyChanged(key, val));
+    const merged = (0,_fastMerge__WEBPACK_IMPORTED_MODULE_8__["default"])(asObject, defaultKeyStates);
+    _OnyxCache__WEBPACK_IMPORTED_MODULE_3__["default"].merge(merged);
+    underscore__WEBPACK_IMPORTED_MODULE_1___default().each(merged, (val, key) => keyChanged(key, val));
   });
 }
 
@@ -1208,19 +1222,19 @@ function clear() {let keysToPreserve = arguments.length > 0 && arguments[0] !==
     //      status, or activeClients need to remain in Onyx even when signed out)
     // 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)
-    underscore__WEBPACK_IMPORTED_MODULE_2___default().each(keys, (key) => {
-      const isKeyToPreserve = underscore__WEBPACK_IMPORTED_MODULE_2___default().contains(keysToPreserve, key);
-      const isDefaultKey = underscore__WEBPACK_IMPORTED_MODULE_2___default().has(defaultKeyStates, key);
+    underscore__WEBPACK_IMPORTED_MODULE_1___default().each(keys, (key) => {
+      const isKeyToPreserve = underscore__WEBPACK_IMPORTED_MODULE_1___default().contains(keysToPreserve, key);
+      const isDefaultKey = underscore__WEBPACK_IMPORTED_MODULE_1___default().has(defaultKeyStates, key);
 
       // If the key is being removed or reset to default:
       // 1. Update it in the cache
       // 2. Figure out whether it is a collection key or not,
       //      since collection key subscribers need to be updated differently
       if (!isKeyToPreserve) {
-        const oldValue = _OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].getValue(key);
-        const newValue = underscore__WEBPACK_IMPORTED_MODULE_2___default().get(defaultKeyStates, key, null);
+        const oldValue = _OnyxCache__WEBPACK_IMPORTED_MODULE_3__["default"].getValue(key);
+        const newValue = underscore__WEBPACK_IMPORTED_MODULE_1___default().get(defaultKeyStates, key, null);
         if (newValue !== oldValue) {
-          _OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].set(key, newValue);
+          _OnyxCache__WEBPACK_IMPORTED_MODULE_3__["default"].set(key, newValue);
           const collectionKey = key.substring(0, key.indexOf('_') + 1);
           if (collectionKey) {
             if (!keyValuesToResetAsCollection[collectionKey]) {
@@ -1242,18 +1256,18 @@ function clear() {let keysToPreserve = arguments.length > 0 && arguments[0] !==
     });
 
     // Notify the subscribers for each key/value group so they can receive the new values
-    underscore__WEBPACK_IMPORTED_MODULE_2___default().each(keyValuesToResetIndividually, (value, key) => {
+    underscore__WEBPACK_IMPORTED_MODULE_1___default().each(keyValuesToResetIndividually, (value, key) => {
       notifySubscribersOnNextTick(key, value);
     });
-    underscore__WEBPACK_IMPORTED_MODULE_2___default().each(keyValuesToResetAsCollection, (value, key) => {
+    underscore__WEBPACK_IMPORTED_MODULE_1___default().each(keyValuesToResetAsCollection, (value, key) => {
       notifyCollectionSubscribersOnNextTick(key, value);
     });
 
-    const defaultKeyValuePairs = underscore__WEBPACK_IMPORTED_MODULE_2___default().pairs(underscore__WEBPACK_IMPORTED_MODULE_2___default().omit(defaultKeyStates, keysToPreserve));
+    const defaultKeyValuePairs = underscore__WEBPACK_IMPORTED_MODULE_1___default().pairs(underscore__WEBPACK_IMPORTED_MODULE_1___default().omit(defaultKeyStates, keysToPreserve));
 
     // Remove only the items that we want cleared from storage, and reset others to default
-    underscore__WEBPACK_IMPORTED_MODULE_2___default().each(keysToBeClearedFromStorage, (key) => _OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].drop(key));
-    return _storage__WEBPACK_IMPORTED_MODULE_5__["default"].removeItems(keysToBeClearedFromStorage).then(() => _storage__WEBPACK_IMPORTED_MODULE_5__["default"].multiSet(defaultKeyValuePairs));
+    underscore__WEBPACK_IMPORTED_MODULE_1___default().each(keysToBeClearedFromStorage, (key) => _OnyxCache__WEBPACK_IMPORTED_MODULE_3__["default"].drop(key));
+    return _storage__WEBPACK_IMPORTED_MODULE_4__["default"].removeItems(keysToBeClearedFromStorage).then(() => _storage__WEBPACK_IMPORTED_MODULE_4__["default"].multiSet(defaultKeyValuePairs));
   });
 }
 
@@ -1272,14 +1286,14 @@ function clear() {let keysToPreserve = arguments.length > 0 && arguments[0] !==
  * @returns {Promise}
  */
 function mergeCollection(collectionKey, collection) {
-  if (!underscore__WEBPACK_IMPORTED_MODULE_2___default().isObject(collection) || underscore__WEBPACK_IMPORTED_MODULE_2___default().isArray(collection) || underscore__WEBPACK_IMPORTED_MODULE_2___default().isEmpty(collection)) {
-    _Logger__WEBPACK_IMPORTED_MODULE_6__.logInfo('mergeCollection() called with invalid or empty value. Skipping this update.');
+  if (!underscore__WEBPACK_IMPORTED_MODULE_1___default().isObject(collection) || underscore__WEBPACK_IMPORTED_MODULE_1___default().isArray(collection) || underscore__WEBPACK_IMPORTED_MODULE_1___default().isEmpty(collection)) {
+    _Logger__WEBPACK_IMPORTED_MODULE_5__.logInfo('mergeCollection() called with invalid or empty value. Skipping this update.');
     return Promise.resolve();
   }
 
   // Confirm all the collection keys belong to the same parent
   let hasCollectionKeyCheckFailed = false;
-  underscore__WEBPACK_IMPORTED_MODULE_2___default().each(collection, (_data, dataKey) => {
+  underscore__WEBPACK_IMPORTED_MODULE_1___default().each(collection, (_data, dataKey) => {
     if (isKeyMatch(collectionKey, dataKey)) {
       return;
     }
@@ -1289,7 +1303,7 @@ function mergeCollection(collectionKey, collection) {
     }
 
     hasCollectionKeyCheckFailed = true;
-    _Logger__WEBPACK_IMPORTED_MODULE_6__.logAlert(`Provided collection doesn't have all its data belonging to the same parent. CollectionKey: ${collectionKey}, DataKey: ${dataKey}`);
+    _Logger__WEBPACK_IMPORTED_MODULE_5__.logAlert(`Provided collection doesn't have all its data belonging to the same parent. CollectionKey: ${collectionKey}, DataKey: ${dataKey}`);
   });
 
   // Gracefully handle bad mergeCollection updates so it doesn't block the merge queue
@@ -1300,13 +1314,13 @@ function mergeCollection(collectionKey, collection) {
   return getAllKeys().
   then((persistedKeys) => {
     // Split to keys that exist in storage and keys that don't
-    const [existingKeys, newKeys] = underscore__WEBPACK_IMPORTED_MODULE_2___default().chain(collection).
+    const [existingKeys, newKeys] = underscore__WEBPACK_IMPORTED_MODULE_1___default().chain(collection).
     keys().
     partition((key) => persistedKeys.includes(key)).
     value();
 
-    const existingKeyCollection = underscore__WEBPACK_IMPORTED_MODULE_2___default().pick(collection, existingKeys);
-    const newCollection = underscore__WEBPACK_IMPORTED_MODULE_2___default().pick(collection, newKeys);
+    const existingKeyCollection = underscore__WEBPACK_IMPORTED_MODULE_1___default().pick(collection, existingKeys);
+    const newCollection = underscore__WEBPACK_IMPORTED_MODULE_1___default().pick(collection, newKeys);
     const keyValuePairsForExistingCollection = prepareKeyValuePairsForStorage(existingKeyCollection);
     const keyValuePairsForNewCollection = prepareKeyValuePairsForStorage(newCollection);
 
@@ -1315,17 +1329,17 @@ function mergeCollection(collectionKey, collection) {
     // 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) {
-      promises.push(_storage__WEBPACK_IMPORTED_MODULE_5__["default"].multiMerge(keyValuePairsForExistingCollection));
+      promises.push(_storage__WEBPACK_IMPORTED_MODULE_4__["default"].multiMerge(keyValuePairsForExistingCollection));
     }
 
     if (keyValuePairsForNewCollection.length > 0) {
-      promises.push(_storage__WEBPACK_IMPORTED_MODULE_5__["default"].multiSet(keyValuePairsForNewCollection));
+      promises.push(_storage__WEBPACK_IMPORTED_MODULE_4__["default"].multiSet(keyValuePairsForNewCollection));
     }
 
     // Prefill cache if necessary by calling get() on any existing keys and then merge original data to cache
     // and update all subscribers
-    Promise.all(underscore__WEBPACK_IMPORTED_MODULE_2___default().map(existingKeys, get)).then(() => {
-      _OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].merge(collection);
+    Promise.all(underscore__WEBPACK_IMPORTED_MODULE_1___default().map(existingKeys, get)).then(() => {
+      _OnyxCache__WEBPACK_IMPORTED_MODULE_3__["default"].merge(collection);
       keysChanged(collectionKey, collection);
     });
 
@@ -1342,11 +1356,11 @@ function mergeCollection(collectionKey, collection) {
  */
 function update(data) {
   // First, validate the Onyx object is in the format we expect
-  underscore__WEBPACK_IMPORTED_MODULE_2___default().each(data, (_ref) => {let { onyxMethod, key } = _ref;
-    if (!underscore__WEBPACK_IMPORTED_MODULE_2___default().contains([METHOD.CLEAR, METHOD.SET, METHOD.MERGE, METHOD.MERGE_COLLECTION], onyxMethod)) {
+  underscore__WEBPACK_IMPORTED_MODULE_1___default().each(data, (_ref) => {let { onyxMethod, key } = _ref;
+    if (!underscore__WEBPACK_IMPORTED_MODULE_1___default().contains([METHOD.CLEAR, METHOD.SET, METHOD.MERGE, METHOD.MERGE_COLLECTION], onyxMethod)) {
       throw new Error(`Invalid onyxMethod ${onyxMethod} in Onyx update.`);
     }
-    if (onyxMethod !== METHOD.CLEAR && !underscore__WEBPACK_IMPORTED_MODULE_2___default().isString(key)) {
+    if (onyxMethod !== METHOD.CLEAR && !underscore__WEBPACK_IMPORTED_MODULE_1___default().isString(key)) {
       throw new Error(`Invalid ${typeof key} key provided in Onyx update. Onyx key must be of type string.`);
     }
   });
@@ -1354,7 +1368,7 @@ function update(data) {
   const promises = [];
   let clearPromise = Promise.resolve();
 
-  underscore__WEBPACK_IMPORTED_MODULE_2___default().each(data, (_ref2) => {let { onyxMethod, key, value } = _ref2;
+  underscore__WEBPACK_IMPORTED_MODULE_1___default().each(data, (_ref2) => {let { onyxMethod, key, value } = _ref2;
     switch (onyxMethod) {
       case METHOD.SET:
         promises.push(() => set(key, value));
@@ -1373,7 +1387,7 @@ function update(data) {
 
   });
 
-  return clearPromise.then(() => Promise.all(underscore__WEBPACK_IMPORTED_MODULE_2___default().map(promises, (p) => p())));
+  return clearPromise.then(() => Promise.all(underscore__WEBPACK_IMPORTED_MODULE_1___default().map(promises, (p) => p())));
 }
 
 /**
@@ -1381,10 +1395,10 @@ function update(data) {
  * @param {string[]} keyList
  */
 function setMemoryOnlyKeys(keyList) {
-  _storage__WEBPACK_IMPORTED_MODULE_5__["default"].setMemoryOnlyKeys(keyList);
+  _storage__WEBPACK_IMPORTED_MODULE_4__["default"].setMemoryOnlyKeys(keyList);
 
   // When in memory only mode for certain keys we do not want to ever drop items from the cache as the user will have no way to recover them again via storage.
-  _OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].setRecentKeysLimit(Infinity);
+  _OnyxCache__WEBPACK_IMPORTED_MODULE_3__["default"].setRecentKeysLimit(Infinity);
 }
 
 /**
@@ -1428,11 +1442,11 @@ function init()
   }
 
   if (debugSetState) {
-    _metrics_PerformanceUtils__WEBPACK_IMPORTED_MODULE_8__.setShouldDebugSetState(true);
+    _metrics_PerformanceUtils__WEBPACK_IMPORTED_MODULE_7__.setShouldDebugSetState(true);
   }
 
   if (maxCachedKeysCount > 0) {
-    _OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].setRecentKeysLimit(maxCachedKeysCount);
+    _OnyxCache__WEBPACK_IMPORTED_MODULE_3__["default"].setRecentKeysLimit(maxCachedKeysCount);
   }
 
   // Let Onyx know about all of our keys
@@ -1451,9 +1465,9 @@ function init()
 
   then(deferredInitTask.resolve);
 
-  if (shouldSyncMultipleInstances && underscore__WEBPACK_IMPORTED_MODULE_2___default().isFunction(_storage__WEBPACK_IMPORTED_MODULE_5__["default"].keepInstancesSync)) {
-    _storage__WEBPACK_IMPORTED_MODULE_5__["default"].keepInstancesSync((key, value) => {
-      _OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].set(key, value);
+  if (shouldSyncMultipleInstances && underscore__WEBPACK_IMPORTED_MODULE_1___default().isFunction(_storage__WEBPACK_IMPORTED_MODULE_4__["default"].keepInstancesSync)) {
+    _storage__WEBPACK_IMPORTED_MODULE_4__["default"].keepInstancesSync((key, value) => {
+      _OnyxCache__WEBPACK_IMPORTED_MODULE_3__["default"].set(key, value);
       keyChanged(key, value);
     });
   }
@@ -1466,12 +1480,11 @@ const Onyx = {
   multiSet,
   merge,
   mergeCollection,
-  hasPendingMergeForKey,
   update,
   clear,
   getAllKeys,
   init,
-  registerLogger: _Logger__WEBPACK_IMPORTED_MODULE_6__.registerLogger,
+  registerLogger: _Logger__WEBPACK_IMPORTED_MODULE_5__.registerLogger,
   addToEvictionBlockList,
   removeFromEvictionBlockList,
   isSafeEvictionKey,
@@ -3741,17 +3754,6 @@ module.exports = __WEBPACK_EXTERNAL_MODULE_localforage_removeitems__;
 
 /***/ }),
 
-/***/ "lodash/get":
-/*!*****************************!*\
-  !*** external "lodash/get" ***!
-  \*****************************/
-/***/ ((module) => {
-
-"use strict";
-module.exports = __WEBPACK_EXTERNAL_MODULE_lodash_get__;
-
-/***/ }),
-
 /***/ "lodash/transform":
 /*!***********************************!*\
   !*** external "lodash/transform" ***!