react-native-onyx 2.0.26 → 2.0.28

package/dist/OnyxUtils.js

@@ -26,9 +26,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/prefer-for-of */
 /* eslint-disable no-continue */
 const fast_equals_1 = require("fast-equals");
-const underscore_1 = __importDefault(require("underscore"));
+const clone_1 = __importDefault(require("lodash/clone"));
 const Logger = __importStar(require("./Logger"));
 const OnyxCache_1 = __importDefault(require("./OnyxCache"));
 const Str = __importStar(require("./Str"));
@@ -66,32 +67,24 @@ let batchUpdatesPromise = null;
 let batchUpdatesQueue = [];
 /**
  * Getter - returns the merge queue.
- *
- * @returns {Object} The callback to state mapping.
  */
 function getMergeQueue() {
     return mergeQueue;
 }
 /**
  * Getter - returns the merge queue promise.
- *
- * @returns {Object} The callback to state mapping.
  */
 function getMergeQueuePromise() {
     return mergeQueuePromise;
 }
 /**
  * Getter - returns the callback to state mapping.
- *
- * @returns {Object} The callback to state mapping.
  */
 function getCallbackToStateMapping() {
     return callbackToStateMapping;
 }
 /**
  * Getter - returns the default key states.
- *
- * @returns {Object} The callback to state mapping.
  */
 function getDefaultKeyStates() {
     return defaultKeyStates;
@@ -99,15 +92,16 @@ function getDefaultKeyStates() {
 /**
  * Sets the initial values for the Onyx store
  *
- * @param {Object} keys - `ONYXKEYS` constants object from Onyx.init()
- * @param {Object} initialKeyStates - initial data to set when `init()` and `clear()` are called
- * @param {Array<String>} safeEvictionKeys - This is an array of keys (individual or collection patterns) that when provided to Onyx are flagged as "safe" for removal.
+ * @param keys - `ONYXKEYS` constants object from Onyx.init()
+ * @param initialKeyStates - initial data to set when `init()` and `clear()` are called
+ * @param safeEvictionKeys - This is an array of keys (individual or collection patterns) that when provided to Onyx are flagged as "safe" for removal.
  */
 function initStoreValues(keys, initialKeyStates, safeEvictionKeys) {
+    var _a;
     // We need the value of the collection keys later for checking if a
     // key is a collection. We store it in a map for faster lookup.
-    const collectionValues = underscore_1.default.values(keys.COLLECTION);
-    onyxCollectionKeyMap = underscore_1.default.reduce(collectionValues, (acc, val) => {
+    const collectionValues = Object.values((_a = keys.COLLECTION) !== null && _a !== void 0 ? _a : {});
+    onyxCollectionKeyMap = collectionValues.reduce((acc, val) => {
         acc.set(val, true);
         return acc;
     }, new Map());
@@ -117,14 +111,6 @@ function initStoreValues(keys, initialKeyStates, safeEvictionKeys) {
     // Let Onyx know about which keys are safe to evict
     evictionAllowList = safeEvictionKeys;
 }
-/**
- * Sends an action to DevTools extension
- *
- * @param {string} method - Onyx method from METHOD
- * @param {string} key - Onyx key that was changed
- * @param {any} value - contains the change that was made by the method
- * @param {any} mergedValue - (optional) value that was written in the storage after a merge method was executed.
- */
 function sendActionToDevTools(method, key, value, mergedValue = undefined) {
     DevTools_1.default.registerAction(utils_1.default.formatActionName(method, key), value, key ? { [key]: mergedValue || value } : value);
 }
@@ -133,7 +119,6 @@ function sendActionToDevTools(method, key, value, mergedValue = undefined) {
  * This happens for example in the Onyx.update function, where we process API responses that might contain a lot of
  * update operations. Instead of calling the subscribers for each update operation, we batch them together which will
  * cause react to schedule the updates at once instead of after each other. This is mainly a performance optimization.
- * @returns {Promise}
  */
 function maybeFlushBatchUpdates() {
     if (batchUpdatesPromise) {
@@ -162,35 +147,19 @@ function batchUpdates(updates) {
     batchUpdatesQueue.push(updates);
     return maybeFlushBatchUpdates();
 }
-/**
- * Uses a selector function to return a simplified version of sourceData
- * @param {Mixed} sourceData
- * @param {Function} selector Function that takes sourceData and returns a simplified version of it
- * @param {Object} [withOnyxInstanceState]
- * @returns {Mixed}
- */
-const getSubsetOfData = (sourceData, selector, withOnyxInstanceState) => selector(sourceData, withOnyxInstanceState);
 /**
  * Takes a collection of items (eg. {testKey_1:{a:'a'}, testKey_2:{b:'b'}})
  * and runs it through a reducer function to return a subset of the data according to a selector.
  * The resulting collection will only contain items that are returned by the selector.
- * @param {Object} collection
- * @param {String|Function} selector (see method docs for getSubsetOfData() for full details)
- * @param {Object} [withOnyxInstanceState]
- * @returns {Object}
- */
-const reduceCollectionWithSelector = (collection, selector, withOnyxInstanceState) => underscore_1.default.reduce(collection, (finalCollection, item, key) => {
-    // eslint-disable-next-line no-param-reassign
-    finalCollection[key] = getSubsetOfData(item, selector, withOnyxInstanceState);
-    return finalCollection;
-}, {});
-/**
- * Get some data from the store
- *
- * @private
- * @param {string} key
- * @returns {Promise<*>}
  */
+function reduceCollectionWithSelector(collection, selector, withOnyxInstanceState) {
+    return Object.entries(collection !== null && collection !== void 0 ? collection : {}).reduce((finalCollection, [key, item]) => {
+        // eslint-disable-next-line no-param-reassign
+        finalCollection[key] = selector(item, withOnyxInstanceState);
+        return finalCollection;
+    }, {});
+}
+/** Get some data from the store */
 function get(key) {
     // When we already have the value in cache - resolve right away
     if (OnyxCache_1.default.hasCacheForKey(key)) {
@@ -210,11 +179,7 @@ function get(key) {
         .catch((err) => Logger.logInfo(`Unable to get item from persistent storage. Key: ${key} Error: ${err}`));
     return OnyxCache_1.default.captureTask(taskName, promise);
 }
-/**
- * Returns current key names stored in persisted storage
- * @private
- * @returns {Promise<Set<Key>>}
- */
+/** Returns current key names stored in persisted storage */
 function getAllKeys() {
     // When we've already read stored keys, resolve right away
     const storedKeys = OnyxCache_1.default.getAllKeys();
@@ -237,25 +202,17 @@ function getAllKeys() {
 /**
  * Checks to see if the a subscriber's supplied key
  * is associated with a collection of keys.
- *
- * @param {String} key
- * @returns {Boolean}
  */
 function isCollectionKey(key) {
     return onyxCollectionKeyMap.has(key);
 }
-/**
- * @param {String} collectionKey
- * @param {String} key
- * @returns {Boolean}
- */
 function isCollectionMemberKey(collectionKey, key) {
     return Str.startsWith(key, collectionKey) && key.length > collectionKey.length;
 }
 /**
  * Splits a collection member key into the collection key part and the ID part.
- * @param {String} key - The collection member key to split.
- * @returns {Array<String>} A tuple where the first element is the collection part and the second element is the ID part.
+ * @param key - The collection member key to split.
+ * @returns A tuple where the first element is the collection part and the second element is the ID part.
  */
 function splitCollectionMemberKey(key) {
     const underscoreIndex = key.indexOf('_');
@@ -267,35 +224,19 @@ function splitCollectionMemberKey(key) {
 /**
  * Checks to see if a provided key is the exact configured key of our connected subscriber
  * or if the provided key is a collection member key (in case our configured key is a "collection key")
- *
- * @private
- * @param {String} configKey
- * @param {String} key
- * @return {Boolean}
  */
 function isKeyMatch(configKey, key) {
     return isCollectionKey(configKey) ? Str.startsWith(key, configKey) : configKey === key;
 }
-/**
- * Checks to see if this key has been flagged as
- * safe for removal.
- *
- * @private
- * @param {String} testKey
- * @returns {Boolean}
- */
+/** Checks to see if this key has been flagged as safe for removal. */
 function isSafeEvictionKey(testKey) {
-    return underscore_1.default.some(evictionAllowList, (key) => isKeyMatch(key, testKey));
+    return evictionAllowList.some((key) => isKeyMatch(key, testKey));
 }
 /**
  * Tries to get a value from the cache. If the value is not present in cache it will return the default value or undefined.
  * If the requested key is a collection, it will return an object with all the collection members.
- *
- * @param {String} key
- * @param {Object} mapping
- * @returns {Mixed}
  */
-function tryGetCachedValue(key, mapping = {}) {
+function tryGetCachedValue(key, mapping) {
     let val = OnyxCache_1.default.getValue(key);
     if (isCollectionKey(key)) {
         const allCacheKeys = OnyxCache_1.default.getAllKeys();
@@ -304,14 +245,8 @@ function tryGetCachedValue(key, mapping = {}) {
         if (allCacheKeys.size === 0) {
             return;
         }
-        const matchingKeys = [];
-        allCacheKeys.forEach((k) => {
-            if (!k.startsWith(key)) {
-                return;
-            }
-            matchingKeys.push(k);
-        });
-        const values = underscore_1.default.reduce(matchingKeys, (finalObject, matchedKey) => {
+        const matchingKeys = Array.from(allCacheKeys).filter((k) => k.startsWith(key));
+        const values = matchingKeys.reduce((finalObject, matchedKey) => {
             const cachedValue = OnyxCache_1.default.getValue(matchedKey);
             if (cachedValue) {
                 // This is permissible because we're in the process of constructing the final object in a reduce function.
@@ -322,31 +257,25 @@ function tryGetCachedValue(key, mapping = {}) {
         }, {});
         val = values;
     }
-    if (mapping.selector) {
+    if (mapping === null || mapping === void 0 ? void 0 : mapping.selector) {
         const state = mapping.withOnyxInstance ? mapping.withOnyxInstance.state : undefined;
         if (isCollectionKey(key)) {
             return reduceCollectionWithSelector(val, mapping.selector, state);
         }
-        return getSubsetOfData(val, mapping.selector, state);
+        return mapping.selector(val, state);
     }
     return val;
 }
 /**
  * Remove a key from the recently accessed key list.
- *
- * @private
- * @param {String} key
  */
 function removeLastAccessedKey(key) {
-    recentlyAccessedKeys = underscore_1.default.without(recentlyAccessedKeys, key);
+    recentlyAccessedKeys = recentlyAccessedKeys.filter((recentlyAccessedKey) => recentlyAccessedKey !== key);
 }
 /**
  * Add a key to the list of recently accessed keys. The least
  * recently accessed key should be at the head and the most
  * recently accessed key at the tail.
- *
- * @private
- * @param {String} key
  */
 function addLastAccessedKey(key) {
     // Only specific keys belong in this list since we cannot remove an entire collection.
@@ -359,25 +288,16 @@ function addLastAccessedKey(key) {
 /**
  * Removes a key previously added to this list
  * which will enable it to be deleted again.
- *
- * @private
- * @param {String} key
- * @param {Number} connectionID
  */
 function removeFromEvictionBlockList(key, connectionID) {
-    evictionBlocklist[key] = underscore_1.default.without(evictionBlocklist[key] || [], connectionID);
+    var _a, _b, _c;
+    evictionBlocklist[key] = (_b = (_a = evictionBlocklist[key]) === null || _a === void 0 ? void 0 : _a.filter((evictionKey) => evictionKey !== connectionID)) !== null && _b !== void 0 ? _b : [];
     // Remove the key if there are no more subscribers
-    if (evictionBlocklist[key].length === 0) {
+    if (((_c = evictionBlocklist[key]) === null || _c === void 0 ? void 0 : _c.length) === 0) {
         delete evictionBlocklist[key];
     }
 }
-/**
- * Keys added to this list can never be deleted.
- *
- * @private
- * @param {String} key
- * @param {Number} connectionID
- */
+/** Keys added to this list can never be deleted. */
 function addToEvictionBlockList(key, connectionID) {
     removeFromEvictionBlockList(key, connectionID);
     if (!evictionBlocklist[key]) {
@@ -390,13 +310,10 @@ function addToEvictionBlockList(key, connectionID) {
  * the recently accessed list when initializing the app. This
  * enables keys that have not recently been accessed to be
  * removed.
- *
- * @private
- * @returns {Promise}
  */
 function addAllSafeEvictionKeysToRecentlyAccessedList() {
     return getAllKeys().then((keys) => {
-        underscore_1.default.each(evictionAllowList, (safeEvictionKey) => {
+        evictionAllowList.forEach((safeEvictionKey) => {
             keys.forEach((key) => {
                 if (!isKeyMatch(safeEvictionKey, key)) {
                     return;
@@ -406,43 +323,26 @@ function addAllSafeEvictionKeysToRecentlyAccessedList() {
         });
     });
 }
-/**
- * @private
- * @param {String} collectionKey
- * @returns {Object}
- */
 function getCachedCollection(collectionKey) {
-    const collectionMemberKeys = [];
-    OnyxCache_1.default.getAllKeys().forEach((storedKey) => {
-        if (!isCollectionMemberKey(collectionKey, storedKey)) {
-            return;
-        }
-        collectionMemberKeys.push(storedKey);
-    });
-    return underscore_1.default.reduce(collectionMemberKeys, (prev, curr) => {
-        const cachedValue = OnyxCache_1.default.getValue(curr);
+    const collectionMemberKeys = Array.from(OnyxCache_1.default.getAllKeys()).filter((storedKey) => isCollectionMemberKey(collectionKey, storedKey));
+    return collectionMemberKeys.reduce((prev, key) => {
+        const cachedValue = OnyxCache_1.default.getValue(key);
         if (!cachedValue) {
             return prev;
         }
         // eslint-disable-next-line no-param-reassign
-        prev[curr] = cachedValue;
+        prev[key] = cachedValue;
         return prev;
     }, {});
 }
 /**
  * When a collection of keys change, search for any callbacks matching the collection key and trigger those callbacks
- *
- * @private
- * @param {String} collectionKey
- * @param {Object} partialCollection - a partial collection of grouped member keys
- * @param {boolean} [notifyRegularSubscibers=true]
- * @param {boolean} [notifyWithOnyxSubscibers=true]
  */
 function keysChanged(collectionKey, partialCollection, notifyRegularSubscibers = true, notifyWithOnyxSubscibers = true) {
     // 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_1.default.keys(callbackToStateMapping);
+    const stateMappingKeys = Object.keys(callbackToStateMapping);
     for (let i = 0; i < stateMappingKeys.length; i++) {
         const subscriber = callbackToStateMapping[stateMappingKeys[i]];
         if (!subscriber) {
@@ -464,7 +364,7 @@ function keysChanged(collectionKey, partialCollection, notifyRegularSubscibers =
         // was merged in via mergeCollection().
         const cachedCollection = getCachedCollection(collectionKey);
         // Regular Onyx.connect() subscriber found.
-        if (underscore_1.default.isFunction(subscriber.callback)) {
+        if (typeof subscriber.callback === 'function') {
             if (!notifyRegularSubscibers) {
                 continue;
             }
@@ -477,7 +377,7 @@ function keysChanged(collectionKey, partialCollection, notifyRegularSubscibers =
                 }
                 // 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_1.default.keys(partialCollection);
+                const dataKeys = Object.keys(partialCollection !== null && partialCollection !== void 0 ? partialCollection : {});
                 for (let j = 0; j < dataKeys.length; j++) {
                     const dataKey = dataKeys[j];
                     subscriber.callback(cachedCollection[dataKey], dataKey);
@@ -487,13 +387,14 @@ function keysChanged(collectionKey, partialCollection, notifyRegularSubscibers =
             // And if the subscriber is specifically only tracking a particular collection member key then we will
             // notify them with the cached data for that key only.
             if (isSubscribedToCollectionMemberKey) {
-                subscriber.callback(cachedCollection[subscriber.key], subscriber.key);
+                const subscriberCallback = subscriber.callback;
+                subscriberCallback(cachedCollection[subscriber.key], subscriber.key);
                 continue;
             }
             continue;
         }
         // React component subscriber found.
-        if (subscriber.withOnyxInstance) {
+        if ('withOnyxInstance' in subscriber && subscriber.withOnyxInstance) {
             if (!notifyWithOnyxSubscibers) {
                 continue;
             }
@@ -502,10 +403,11 @@ function keysChanged(collectionKey, partialCollection, notifyRegularSubscibers =
             if (isSubscribedToCollectionKey) {
                 // If the subscriber has a selector, then the component's state must only be updated with the data
                 // returned by the selector.
-                if (subscriber.selector) {
+                const collectionSelector = subscriber.selector;
+                if (collectionSelector) {
                     subscriber.withOnyxInstance.setStateProxy((prevState) => {
                         const previousData = prevState[subscriber.statePropertyName];
-                        const newData = reduceCollectionWithSelector(cachedCollection, subscriber.selector, subscriber.withOnyxInstance.state);
+                        const newData = reduceCollectionWithSelector(cachedCollection, collectionSelector, subscriber.withOnyxInstance.state);
                         if (!(0, fast_equals_1.deepEqual)(previousData, newData)) {
                             return {
                                 [subscriber.statePropertyName]: newData,
@@ -516,13 +418,14 @@ function keysChanged(collectionKey, partialCollection, notifyRegularSubscibers =
                     continue;
                 }
                 subscriber.withOnyxInstance.setStateProxy((prevState) => {
-                    const finalCollection = underscore_1.default.clone(prevState[subscriber.statePropertyName] || {});
-                    const dataKeys = underscore_1.default.keys(partialCollection);
+                    var _a;
+                    const finalCollection = (0, clone_1.default)((_a = prevState === null || prevState === void 0 ? void 0 : prevState[subscriber.statePropertyName]) !== null && _a !== void 0 ? _a : {});
+                    const dataKeys = Object.keys(partialCollection !== null && partialCollection !== void 0 ? partialCollection : {});
                     for (let j = 0; j < dataKeys.length; j++) {
                         const dataKey = dataKeys[j];
                         finalCollection[dataKey] = cachedCollection[dataKey];
                     }
-                    PerformanceUtils.logSetStateCall(subscriber, prevState[subscriber.statePropertyName], finalCollection, 'keysChanged', collectionKey);
+                    PerformanceUtils.logSetStateCall(subscriber, prevState === null || prevState === void 0 ? void 0 : prevState[subscriber.statePropertyName], finalCollection, 'keysChanged', collectionKey);
                     return {
                         [subscriber.statePropertyName]: finalCollection,
                     };
@@ -533,17 +436,18 @@ function keysChanged(collectionKey, partialCollection, notifyRegularSubscibers =
             if (isSubscribedToCollectionMemberKey) {
                 // 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_1.default.isUndefined(dataFromCollection)) {
+                const dataFromCollection = partialCollection === null || partialCollection === void 0 ? void 0 : partialCollection[subscriber.key];
+                if (dataFromCollection === undefined) {
                     continue;
                 }
                 // If the subscriber has a selector, then the component's state must only be updated with the data
                 // returned by the selector and the state should only change when the subset of data changes from what
                 // it was previously.
-                if (subscriber.selector) {
+                const selector = subscriber.selector;
+                if (selector) {
                     subscriber.withOnyxInstance.setStateProxy((prevState) => {
                         const prevData = prevState[subscriber.statePropertyName];
-                        const newData = getSubsetOfData(cachedCollection[subscriber.key], subscriber.selector, subscriber.withOnyxInstance.state);
+                        const newData = selector(cachedCollection[subscriber.key], subscriber.withOnyxInstance.state);
                         if (!(0, fast_equals_1.deepEqual)(prevData, newData)) {
                             PerformanceUtils.logSetStateCall(subscriber, prevData, newData, 'keysChanged', collectionKey);
                             return {
@@ -578,18 +482,10 @@ function keysChanged(collectionKey, partialCollection, notifyRegularSubscibers =
  *
  * @example
  * keyChanged(key, value, subscriber => subscriber.initWithStoredValues === false)
- *
- * @private
- * @param {String} key
- * @param {*} data
- * @param {*} prevData
- * @param {Function} [canUpdateSubscriber] only subscribers that pass this truth test will be updated
- * @param {boolean} [notifyRegularSubscibers=true]
- * @param {boolean} [notifyWithOnyxSubscibers=true]
  */
 function keyChanged(key, data, prevData, canUpdateSubscriber = () => true, notifyRegularSubscibers = true, notifyWithOnyxSubscibers = true) {
     // Add or remove this key from the recentlyAccessedKeys lists
-    if (!underscore_1.default.isNull(data)) {
+    if (data !== null) {
         addLastAccessedKey(key);
     }
     else {
@@ -598,14 +494,14 @@ function keyChanged(key, data, prevData, canUpdateSubscriber = () => true, notif
     // 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_1.default.keys(callbackToStateMapping);
+    const stateMappingKeys = Object.keys(callbackToStateMapping);
     for (let i = 0; i < stateMappingKeys.length; i++) {
         const subscriber = callbackToStateMapping[stateMappingKeys[i]];
         if (!subscriber || !isKeyMatch(subscriber.key, key) || !canUpdateSubscriber(subscriber)) {
             continue;
         }
         // Subscriber is a regular call to connect() and provided a callback
-        if (underscore_1.default.isFunction(subscriber.callback)) {
+        if (typeof subscriber.callback === 'function') {
             if (!notifyRegularSubscibers) {
                 continue;
             }
@@ -615,23 +511,25 @@ function keyChanged(key, data, prevData, canUpdateSubscriber = () => true, notif
                 subscriber.callback(cachedCollection);
                 continue;
             }
-            subscriber.callback(data, key);
+            const subscriberCallback = subscriber.callback;
+            subscriberCallback(data, key);
             continue;
         }
         // Subscriber connected via withOnyx() HOC
-        if (subscriber.withOnyxInstance) {
+        if ('withOnyxInstance' in subscriber && subscriber.withOnyxInstance) {
             if (!notifyWithOnyxSubscibers) {
                 continue;
             }
+            const selector = subscriber.selector;
             // Check if we are subscribing to a collection key and overwrite the collection member key value in state
             if (isCollectionKey(subscriber.key)) {
                 // If the subscriber has a selector, then the consumer of this data must only be given the data
                 // returned by the selector and only when the selected data has changed.
-                if (subscriber.selector) {
+                if (selector) {
                     subscriber.withOnyxInstance.setStateProxy((prevState) => {
                         const prevWithOnyxData = prevState[subscriber.statePropertyName];
                         const newWithOnyxData = {
-                            [key]: getSubsetOfData(data, subscriber.selector, subscriber.withOnyxInstance.state),
+                            [key]: selector(data, subscriber.withOnyxInstance.state),
                         };
                         const prevDataWithNewData = Object.assign(Object.assign({}, prevWithOnyxData), newWithOnyxData);
                         if (!(0, fast_equals_1.deepEqual)(prevWithOnyxData, prevDataWithNewData)) {
@@ -656,10 +554,10 @@ function keyChanged(key, data, prevData, canUpdateSubscriber = () => true, notif
             }
             // If the subscriber has a selector, then the component's state must only be updated with the data
             // returned by the selector and only if the selected data has changed.
-            if (subscriber.selector) {
+            if (selector) {
                 subscriber.withOnyxInstance.setStateProxy(() => {
-                    const previousValue = getSubsetOfData(prevData, subscriber.selector, subscriber.withOnyxInstance.state);
-                    const newValue = getSubsetOfData(data, subscriber.selector, subscriber.withOnyxInstance.state);
+                    const previousValue = selector(prevData, subscriber.withOnyxInstance.state);
+                    const newValue = selector(data, subscriber.withOnyxInstance.state);
                     if (!(0, fast_equals_1.deepEqual)(previousValue, newValue)) {
                         return {
                             [subscriber.statePropertyName]: newValue,
@@ -693,24 +591,15 @@ function keyChanged(key, data, prevData, canUpdateSubscriber = () => true, notif
  * Sends the data obtained from the keys to the connection. It either:
  *     - sets state on the withOnyxInstances
  *     - triggers the callback function
- *
- * @private
- * @param {Object} mapping
- * @param {Object} [mapping.withOnyxInstance]
- * @param {String} [mapping.statePropertyName]
- * @param {Function} [mapping.callback]
- * @param {String} [mapping.selector]
- * @param {*|null} val
- * @param {String|undefined} matchedKey
- * @param {Boolean} isBatched
  */
 function sendDataToConnection(mapping, val, matchedKey, isBatched) {
+    var _a, _b;
     // If the mapping no longer exists then we should not send any data.
     // This means our subscriber disconnected or withOnyx wrapped component unmounted.
     if (!callbackToStateMapping[mapping.connectionID]) {
         return;
     }
-    if (mapping.withOnyxInstance) {
+    if ('withOnyxInstance' in mapping && mapping.withOnyxInstance) {
         let newData = val;
         // If the mapping has a selector, then the component's state must only be updated with the data
         // returned by the selector.
@@ -719,30 +608,23 @@ function sendDataToConnection(mapping, val, matchedKey, isBatched) {
                 newData = reduceCollectionWithSelector(val, mapping.selector, mapping.withOnyxInstance.state);
             }
             else {
-                newData = getSubsetOfData(val, mapping.selector, mapping.withOnyxInstance.state);
+                newData = mapping.selector(val, mapping.withOnyxInstance.state);
             }
         }
         PerformanceUtils.logSetStateCall(mapping, null, newData, 'sendDataToConnection');
         if (isBatched) {
-            batchUpdates(() => {
-                mapping.withOnyxInstance.setWithOnyxState(mapping.statePropertyName, newData);
-            });
+            batchUpdates(() => mapping.withOnyxInstance.setWithOnyxState(mapping.statePropertyName, newData));
         }
         else {
             mapping.withOnyxInstance.setWithOnyxState(mapping.statePropertyName, newData);
         }
         return;
     }
-    if (underscore_1.default.isFunction(mapping.callback)) {
-        mapping.callback(val, matchedKey);
-    }
+    (_b = (_a = mapping).callback) === null || _b === void 0 ? void 0 : _b.call(_a, val, matchedKey);
 }
 /**
  * We check to see if this key is flagged as safe for eviction and add it to the recentlyAccessedKeys list so that when we
  * run out of storage the least recently accessed key can be removed.
- *
- * @private
- * @param {Object} mapping
  */
 function addKeyToRecentlyAccessedIfNeeded(mapping) {
     if (!isSafeEvictionKey(mapping.key)) {
@@ -750,9 +632,9 @@ function addKeyToRecentlyAccessedIfNeeded(mapping) {
     }
     // Try to free some cache whenever we connect to a safe eviction key
     OnyxCache_1.default.removeLeastRecentlyUsedKeys();
-    if (mapping.withOnyxInstance && !isCollectionKey(mapping.key)) {
+    if ('withOnyxInstance' in mapping && 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_1.default.isUndefined(mapping.canEvict)) {
+        if (mapping.canEvict === undefined) {
             throw new Error(`Cannot subscribe to safe eviction key '${mapping.key}' without providing a canEvict value.`);
         }
         addLastAccessedKey(mapping.key);
@@ -760,10 +642,6 @@ function addKeyToRecentlyAccessedIfNeeded(mapping) {
 }
 /**
  * Gets the data for a given an array of matching keys, combines them into an object, and sends the result back to the subscriber.
- *
- * @private
- * @param {Array} matchingKeys
- * @param {Object} mapping
  */
 function getCollectionDataAndSendAsObject(matchingKeys, mapping) {
     // Keys that are not in the cache
@@ -808,7 +686,7 @@ function getCollectionDataAndSendAsObject(matchingKeys, mapping) {
         // We are going to get the missing keys using multiGet from the storage.
         .then(() => {
         if (missingKeys.length === 0) {
-            return Promise.resolve();
+            return Promise.resolve(undefined);
         }
         return storage_1.default.multiGet(missingKeys);
     })
@@ -819,9 +697,9 @@ function getCollectionDataAndSendAsObject(matchingKeys, mapping) {
         }
         // temp object is used to merge the missing data into the cache
         const temp = {};
-        values.forEach((value) => {
-            data[value[0]] = value[1];
-            temp[value[0]] = value[1];
+        values.forEach(([key, value]) => {
+            data[key] = value;
+            temp[key] = value;
         });
         OnyxCache_1.default.merge(temp);
         return Promise.resolve();
@@ -836,49 +714,31 @@ function getCollectionDataAndSendAsObject(matchingKeys, mapping) {
  *
  * @example
  * scheduleSubscriberUpdate(key, value, subscriber => subscriber.initWithStoredValues === false)
- *
- * @param {String} key
- * @param {*} value
- * @param {*} prevValue
- * @param {Function} [canUpdateSubscriber] only subscribers that pass this truth test will be updated
- * @returns {Promise}
  */
 function scheduleSubscriberUpdate(key, value, prevValue, canUpdateSubscriber = () => true) {
     const promise = Promise.resolve().then(() => keyChanged(key, value, prevValue, canUpdateSubscriber, true, false));
     batchUpdates(() => keyChanged(key, value, prevValue, canUpdateSubscriber, false, true));
-    return Promise.all([maybeFlushBatchUpdates(), promise]);
+    return Promise.all([maybeFlushBatchUpdates(), promise]).then(() => undefined);
 }
 /**
  * This method is similar to notifySubscribersOnNextTick but it is built for working specifically with collections
  * so that keysChanged() is triggered for the collection and not keyChanged(). If this was not done, then the
  * subscriber callbacks receive the data in a different format than they normally expect and it breaks code.
- *
- * @param {String} key
- * @param {*} value
- * @returns {Promise}
  */
 function scheduleNotifyCollectionSubscribers(key, value) {
     const promise = Promise.resolve().then(() => keysChanged(key, value, true, false));
     batchUpdates(() => keysChanged(key, value, false, true));
-    return Promise.all([maybeFlushBatchUpdates(), promise]);
+    return Promise.all([maybeFlushBatchUpdates(), promise]).then(() => undefined);
 }
 /**
  * Remove a key from Onyx and update the subscribers
- *
- * @private
- * @param {String} key
- * @return {Promise}
  */
 function remove(key) {
     const prevValue = OnyxCache_1.default.getValue(key, false);
     OnyxCache_1.default.drop(key);
     scheduleSubscriberUpdate(key, null, prevValue);
-    return storage_1.default.removeItem(key);
+    return storage_1.default.removeItem(key).then(() => undefined);
 }
-/**
- * @private
- * @returns {Promise<void>}
- */
 function reportStorageQuota() {
     return storage_1.default.getDatabaseSize()
         .then(({ bytesUsed, bytesRemaining }) => {
@@ -892,12 +752,6 @@ function reportStorageQuota() {
  * If we fail to set or merge we must handle this by
  * evicting some data from Onyx and then retrying to do
  * whatever it is we attempted to do.
- *
- * @private
- * @param {Error} error
- * @param {Function} onyxMethod
- * @param  {...any} args
- * @return {Promise}
  */
 function evictStorageAndRetry(error, onyxMethod, ...args) {
     Logger.logInfo(`Failed to save to storage. Error: ${error}. onyxMethod: ${onyxMethod.name}`);
@@ -906,7 +760,7 @@ function evictStorageAndRetry(error, onyxMethod, ...args) {
         throw error;
     }
     // Find the first key that we can remove that has no subscribers in our blocklist
-    const keyForRemoval = underscore_1.default.find(recentlyAccessedKeys, (key) => !evictionBlocklist[key]);
+    const keyForRemoval = recentlyAccessedKeys.find((key) => !evictionBlocklist[key]);
     if (!keyForRemoval) {
         // If we have no acceptable keys to remove then we are possibly trying to save mission critical data. If this is the case,
         // then we should stop retrying as there is not much the user can do to fix this. Instead of getting them stuck in an infinite loop we
@@ -917,16 +771,11 @@ function evictStorageAndRetry(error, onyxMethod, ...args) {
     // Remove the least recently viewed key that is not currently being accessed and retry.
     Logger.logInfo(`Out of storage. Evicting least recently accessed key (${keyForRemoval}) and retrying.`);
     reportStorageQuota();
+    // @ts-expect-error No overload matches this call.
     return remove(keyForRemoval).then(() => onyxMethod(...args));
 }
 /**
- * Notifys subscribers and writes current value to cache
- *
- * @param {String} key
- * @param {*} value
- * @param {Boolean} hasChanged
- * @param {Boolean} wasRemoved
- * @returns {Promise}
+ * Notifies subscribers and writes current value to cache
  */
 function broadcastUpdate(key, value, hasChanged, wasRemoved = false) {
     const prevValue = OnyxCache_1.default.getValue(key, false);
@@ -938,24 +787,19 @@ function broadcastUpdate(key, value, hasChanged, wasRemoved = false) {
     else {
         OnyxCache_1.default.addToAccessedKeys(key);
     }
-    return scheduleSubscriberUpdate(key, value, prevValue, (subscriber) => hasChanged || subscriber.initWithStoredValues === false);
+    return scheduleSubscriberUpdate(key, value, prevValue, (subscriber) => hasChanged || (subscriber === null || subscriber === void 0 ? void 0 : subscriber.initWithStoredValues) === false).then(() => undefined);
 }
-/**
- * @param {String} key
- * @returns {Boolean}
- */
 function hasPendingMergeForKey(key) {
-    return Boolean(mergeQueue[key]);
+    return !!mergeQueue[key];
 }
 /**
  * Removes a key from storage if the value is null.
  * Otherwise removes all nested null values in objects and returns the object
- * @param {String} key
- * @param {Mixed} value
- * @returns {Mixed} The value without null values and a boolean "wasRemoved", which indicates if the key got removed completely
+ *
+ * @returns The value without null values and a boolean "wasRemoved", which indicates if the key got removed completely
  */
 function removeNullValues(key, value) {
-    if (underscore_1.default.isNull(value)) {
+    if (value === null) {
         remove(key);
         return { value, wasRemoved: true };
     }
@@ -968,16 +812,16 @@ function removeNullValues(key, value) {
  * Storage expects array like: [["@MyApp_user", value_1], ["@MyApp_key", value_2]]
  * This method transforms an object like {'@MyApp_user': myUserValue, '@MyApp_key': myKeyValue}
  * to an array of key-value pairs in the above format and removes key-value pairs that are being set to null
- * @private
- * @param {Record} data
- * @return {Array} an array of key - value pairs <[key, value]>
+
+* @return an array of key - value pairs <[key, value]>
  */
 function prepareKeyValuePairsForStorage(data) {
     const keyValuePairs = [];
-    underscore_1.default.forEach(data, (value, key) => {
+    Object.entries(data).forEach(([key, value]) => {
         const { value: valueAfterRemoving, wasRemoved } = removeNullValues(key, value);
-        if (wasRemoved)
+        if (wasRemoved) {
             return;
+        }
         keyValuePairs.push([key, valueAfterRemoving]);
     });
     return keyValuePairs;
@@ -985,20 +829,16 @@ function prepareKeyValuePairsForStorage(data) {
 /**
  * Merges an array of changes with an existing value
  *
- * @private
- * @param {*} existingValue
- * @param {Array<*>} changes Array of changes that should be applied to the existing value
- * @param {Boolean} shouldRemoveNullObjectValues
- * @returns {*}
+ * @param changes Array of changes that should be applied to the existing value
  */
 function applyMerge(existingValue, changes, shouldRemoveNullObjectValues) {
-    const lastChange = underscore_1.default.last(changes);
-    if (underscore_1.default.isArray(lastChange)) {
+    const lastChange = changes === null || changes === void 0 ? void 0 : changes.at(-1);
+    if (Array.isArray(lastChange)) {
         return lastChange;
     }
-    if (underscore_1.default.some(changes, underscore_1.default.isObject)) {
+    if (changes.some((change) => typeof change === 'object')) {
         // Object values are then merged one after the other
-        return underscore_1.default.reduce(changes, (modifiedData, change) => utils_1.default.fastMerge(modifiedData, change, shouldRemoveNullObjectValues), existingValue || {});
+        return changes.reduce((modifiedData, change) => utils_1.default.fastMerge(modifiedData, change, shouldRemoveNullObjectValues), existingValue || {});
     }
     // If we have anything else we can't merge it so we'll
     // simply return the last value that was queued
@@ -1006,15 +846,13 @@ function applyMerge(existingValue, changes, shouldRemoveNullObjectValues) {
 }
 /**
  * Merge user provided default key value pairs.
- * @private
- * @returns {Promise}
  */
 function initializeWithDefaultKeyStates() {
-    return storage_1.default.multiGet(underscore_1.default.keys(defaultKeyStates)).then((pairs) => {
-        const existingDataAsObject = underscore_1.default.object(pairs);
+    return storage_1.default.multiGet(Object.keys(defaultKeyStates)).then((pairs) => {
+        const existingDataAsObject = Object.fromEntries(pairs);
         const merged = utils_1.default.fastMerge(existingDataAsObject, defaultKeyStates);
-        OnyxCache_1.default.merge(merged);
-        underscore_1.default.each(merged, (val, key) => keyChanged(key, val, existingDataAsObject));
+        OnyxCache_1.default.merge(merged !== null && merged !== void 0 ? merged : {});
+        Object.entries(merged !== null && merged !== void 0 ? merged : {}).forEach(([key, value]) => keyChanged(key, value, existingDataAsObject));
     });
 }
 const OnyxUtils = {