react-native-onyx 2.0.52 → 2.0.54

package/dist/Onyx.js

@@ -146,10 +146,11 @@ function connect(connectOptions) {
                     return;
                 }
                 // We did not opt into using waitForCollectionCallback mode so the callback is called for every matching key.
-                // eslint-disable-next-line @typescript-eslint/prefer-for-of
-                for (let i = 0; i < matchingKeys.length; i++) {
-                    OnyxUtils_1.default.get(matchingKeys[i]).then((val) => OnyxUtils_1.default.sendDataToConnection(mapping, val, matchingKeys[i], true));
-                }
+                OnyxUtils_1.default.multiGet(matchingKeys).then((values) => {
+                    values.forEach((val, key) => {
+                        OnyxUtils_1.default.sendDataToConnection(mapping, val, key, true);
+                    });
+                });
                 return;
             }
             // If we are not subscribed to a collection key then there's only a single key to send an update for.
@@ -386,7 +387,8 @@ function mergeCollection(collectionKey, collection) {
     const mergedCollection = collection;
     // Confirm all the collection keys belong to the same parent
     let hasCollectionKeyCheckFailed = false;
-    Object.keys(mergedCollection).forEach((dataKey) => {
+    const mergedCollectionKeys = Object.keys(mergedCollection);
+    mergedCollectionKeys.forEach((dataKey) => {
         if (OnyxUtils_1.default.isKeyMatch(collectionKey, dataKey)) {
             return;
         }
@@ -403,7 +405,7 @@ function mergeCollection(collectionKey, collection) {
     return OnyxUtils_1.default.getAllKeys()
         .then((persistedKeys) => {
         // Split to keys that exist in storage and keys that don't
-        const keys = Object.keys(mergedCollection).filter((key) => {
+        const keys = mergedCollectionKeys.filter((key) => {
             if (mergedCollection[key] === null) {
                 OnyxUtils_1.default.remove(key);
                 return false;
@@ -412,7 +414,6 @@ function mergeCollection(collectionKey, collection) {
         });
         const existingKeys = keys.filter((key) => persistedKeys.has(key));
         const cachedCollectionForExistingKeys = OnyxUtils_1.default.getCachedCollection(collectionKey, existingKeys);
-        const newKeys = keys.filter((key) => !persistedKeys.has(key));
         const existingKeyCollection = existingKeys.reduce((obj, key) => {
             const { isCompatible, existingValueType, newValueType } = utils_1.default.checkCompatibilityWithExistingValue(mergedCollection[key], cachedCollectionForExistingKeys[key]);
             if (!isCompatible) {
@@ -423,11 +424,13 @@ function mergeCollection(collectionKey, collection) {
             obj[key] = mergedCollection[key];
             return obj;
         }, {});
-        const newCollection = newKeys.reduce((obj, key) => {
-            // eslint-disable-next-line no-param-reassign
-            obj[key] = mergedCollection[key];
-            return obj;
-        }, {});
+        const newCollection = {};
+        keys.forEach((key) => {
+            if (persistedKeys.has(key)) {
+                return;
+            }
+            newCollection[key] = mergedCollection[key];
+        });
         // When (multi-)merging the values with the existing values in storage,
         // we don't want to remove nested null values from the data that we pass to the storage layer,
         // because the storage layer uses them to remove nested keys from storage natively.

package/dist/OnyxUtils.d.ts

@@ -54,6 +54,7 @@ declare function maybeFlushBatchUpdates(): Promise<void>;
 declare function batchUpdates(updates: () => void): Promise<void>;
 /** Get some data from the store */
 declare function get<TKey extends OnyxKey, TValue extends OnyxValue<TKey>>(key: TKey): Promise<TValue>;
+declare function multiGet<TKey extends OnyxKey>(keys: CollectionKeyBase[]): Promise<Map<OnyxKey, OnyxValue<TKey>>>;
 /** Returns current key names stored in persisted storage */
 declare function getAllKeys(): Promise<Set<OnyxKey>>;
 /**
@@ -237,5 +238,6 @@ declare const OnyxUtils: {
     applyMerge: typeof applyMerge;
     initializeWithDefaultKeyStates: typeof initializeWithDefaultKeyStates;
     getSnapshotKey: typeof getSnapshotKey;
+    multiGet: typeof multiGet;
 };
 export default OnyxUtils;

package/dist/OnyxUtils.js

@@ -190,6 +190,69 @@ 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);
 }
+// multiGet the data first from the cache and then from the storage for the missing keys.
+function multiGet(keys) {
+    // Keys that are not in the cache
+    const missingKeys = [];
+    // Tasks that are pending
+    const pendingTasks = [];
+    // Keys for the tasks that are pending
+    const pendingKeys = [];
+    // Data to be sent back to the invoker
+    const dataMap = new Map();
+    /**
+     * We are going to iterate over all the matching keys and check if we have the data in the cache.
+     * If we do then we add it to the data object. If we do not have them, then we check if there is a pending task
+     * for the key. If there is such task, then we add the promise to the pendingTasks array and the key to the pendingKeys
+     * array. If there is no pending task then we add the key to the missingKeys array.
+     *
+     * These missingKeys will be later used to multiGet the data from the storage.
+     */
+    keys.forEach((key) => {
+        const cacheValue = OnyxCache_1.default.get(key);
+        if (cacheValue) {
+            dataMap.set(key, cacheValue);
+            return;
+        }
+        const pendingKey = `get:${key}`;
+        if (OnyxCache_1.default.hasPendingTask(pendingKey)) {
+            pendingTasks.push(OnyxCache_1.default.getTaskPromise(pendingKey));
+            pendingKeys.push(key);
+        }
+        else {
+            missingKeys.push(key);
+        }
+    });
+    return (Promise.all(pendingTasks)
+        // Wait for all the pending tasks to resolve and then add the data to the data map.
+        .then((values) => {
+        values.forEach((value, index) => {
+            dataMap.set(pendingKeys[index], value);
+        });
+        return Promise.resolve();
+    })
+        // Get the missing keys using multiGet from the storage.
+        .then(() => {
+        if (missingKeys.length === 0) {
+            return Promise.resolve(undefined);
+        }
+        return storage_1.default.multiGet(missingKeys);
+    })
+        // Add the data from the missing keys to the data map and also merge it to the cache.
+        .then((values) => {
+        if (!values || values.length === 0) {
+            return dataMap;
+        }
+        // temp object is used to merge the missing data into the cache
+        const temp = {};
+        values.forEach(([key, value]) => {
+            dataMap.set(key, value);
+            temp[key] = value;
+        });
+        OnyxCache_1.default.merge(temp);
+        return dataMap;
+    }));
+}
 /** Returns current key names stored in persisted storage */
 function getAllKeys() {
     // When we've already read stored keys, resolve right away
@@ -682,68 +745,8 @@ 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.
  */
 function getCollectionDataAndSendAsObject(matchingKeys, mapping) {
-    // Keys that are not in the cache
-    const missingKeys = [];
-    // Tasks that are pending
-    const pendingTasks = [];
-    // Keys for the tasks that are pending
-    const pendingKeys = [];
-    // We are going to combine all the data from the matching keys into a single object
-    const data = {};
-    /**
-     * We are going to iterate over all the matching keys and check if we have the data in the cache.
-     * If we do then we add it to the data object. If we do not then we check if there is a pending task
-     * for the key. If there is then we add the promise to the pendingTasks array and the key to the pendingKeys
-     * array. If there is no pending task then we add the key to the missingKeys array.
-     *
-     * These missingKeys will be later to use to multiGet the data from the storage.
-     */
-    matchingKeys.forEach((key) => {
-        const cacheValue = OnyxCache_1.default.get(key);
-        if (cacheValue) {
-            data[key] = cacheValue;
-            return;
-        }
-        const pendingKey = `get:${key}`;
-        if (OnyxCache_1.default.hasPendingTask(pendingKey)) {
-            pendingTasks.push(OnyxCache_1.default.getTaskPromise(pendingKey));
-            pendingKeys.push(key);
-        }
-        else {
-            missingKeys.push(key);
-        }
-    });
-    Promise.all(pendingTasks)
-        // We are going to wait for all the pending tasks to resolve and then add the data to the data object.
-        .then((values) => {
-        values.forEach((value, index) => {
-            data[pendingKeys[index]] = value;
-        });
-        return Promise.resolve();
-    })
-        // We are going to get the missing keys using multiGet from the storage.
-        .then(() => {
-        if (missingKeys.length === 0) {
-            return Promise.resolve(undefined);
-        }
-        return storage_1.default.multiGet(missingKeys);
-    })
-        // We are going to add the data from the missing keys to the data object and also merge it to the cache.
-        .then((values) => {
-        if (!values || values.length === 0) {
-            return Promise.resolve();
-        }
-        // temp object is used to merge the missing data into the cache
-        const temp = {};
-        values.forEach(([key, value]) => {
-            data[key] = value;
-            temp[key] = value;
-        });
-        OnyxCache_1.default.merge(temp);
-        return Promise.resolve();
-    })
-        // We are going to send the data to the subscriber.
-        .finally(() => {
+    multiGet(matchingKeys).then((dataMap) => {
+        const data = Object.fromEntries(dataMap.entries());
         sendDataToConnection(mapping, data, undefined, true);
     });
 }
@@ -936,5 +939,6 @@ const OnyxUtils = {
     applyMerge,
     initializeWithDefaultKeyStates,
     getSnapshotKey,
+    multiGet,
 };
 exports.default = OnyxUtils;

package/dist/useOnyx.d.ts

@@ -1,5 +1,5 @@
 import type { IsEqual } from 'type-fest';
-import type { CollectionKeyBase, OnyxCollection, OnyxKey, OnyxValue, Selector } from './types';
+import type { CollectionKeyBase, OnyxCollection, OnyxEntry, OnyxKey, OnyxValue, Selector } from './types';
 type BaseUseOnyxOptions = {
     /**
      * Determines if this key in this subscription is safe to be evicted.
@@ -30,7 +30,8 @@ type UseOnyxSelectorOption<TKey extends OnyxKey, TReturnValue> = {
     selector?: Selector<TKey, unknown, TReturnValue>;
 };
 type FetchStatus = 'loading' | 'loaded';
-type CachedValue<TKey extends OnyxKey, TValue> = IsEqual<TValue, OnyxValue<TKey>> extends true ? TValue : TKey extends CollectionKeyBase ? NonNullable<OnyxCollection<TValue>> : TValue;
+type SelectedValue<TKey, TValue> = TKey extends CollectionKeyBase ? OnyxCollection<TValue> : OnyxEntry<TValue>;
+type CachedValue<TKey extends OnyxKey, TValue> = IsEqual<TValue, OnyxValue<TKey>> extends true ? TValue : SelectedValue<TKey, TValue>;
 type ResultMetadata = {
     status: FetchStatus;
 };

package/dist/utils.js

@@ -11,7 +11,7 @@ function isEmptyObject(obj) {
  */
 function isMergeableObject(value) {
     const isNonNullObject = value != null ? typeof value === 'object' : false;
-    return isNonNullObject && Object.prototype.toString.call(value) !== '[object RegExp]' && Object.prototype.toString.call(value) !== '[object Date]' && !Array.isArray(value);
+    return isNonNullObject && !(value instanceof RegExp) && !(value instanceof Date) && !Array.isArray(value);
 }
 /**
  * Merges the source object into the target object.
@@ -28,9 +28,8 @@ function mergeObject(target, source, shouldRemoveNestedNulls = true) {
     // If "shouldRemoveNestedNulls" is true, we want to remove null values from the merged object
     // and therefore we need to omit keys where either the source or target value is null.
     if (targetObject) {
-        const targetKeys = Object.keys(targetObject);
-        for (let i = 0; i < targetKeys.length; ++i) {
-            const key = targetKeys[i];
+        // eslint-disable-next-line no-restricted-syntax, guard-for-in
+        for (const key in targetObject) {
             const sourceValue = source === null || source === void 0 ? void 0 : source[key];
             const targetValue = targetObject === null || targetObject === void 0 ? void 0 : targetObject[key];
             // If "shouldRemoveNestedNulls" is true, we want to remove null values from the merged object.
@@ -46,9 +45,8 @@ function mergeObject(target, source, shouldRemoveNestedNulls = true) {
         }
     }
     // After copying over all keys from the target object, we want to merge the source object into the destination object.
-    const sourceKeys = Object.keys(source);
-    for (let i = 0; i < sourceKeys.length; ++i) {
-        const key = sourceKeys[i];
+    // eslint-disable-next-line no-restricted-syntax, guard-for-in
+    for (const key in source) {
         const sourceValue = source === null || source === void 0 ? void 0 : source[key];
         const targetValue = targetObject === null || targetObject === void 0 ? void 0 : targetObject[key];
         // If undefined is passed as the source value for a key, we want to generally ignore it.

package/package.json

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