react-native-onyx 2.0.115 → 2.0.116

package/dist/OnyxCache.d.ts

@@ -19,6 +19,8 @@ declare class OnyxCache {
     private recentKeys;
     /** A map of cached values */
     private storageMap;
+    /** Index mapping collection keys to their member keys for O(1) lookup */
+    private collectionIndex;
     /**
      * Captured pending tasks for already running storage methods
      * Using a map yields better performance on operations such a delete
@@ -32,6 +34,8 @@ declare class OnyxCache {
     private evictionBlocklist;
     /** List of keys that have been directly subscribed to or recently modified from least to most recent */
     private recentlyAccessedKeys;
+    /** Set of collection keys for fast lookup */
+    private collectionKeys;
     constructor();
     /** Get all the storage keys */
     getAllKeys(): Set<OnyxKey>;
@@ -145,6 +149,26 @@ declare class OnyxCache {
      * Finds a key that can be safely evicted
      */
     getKeyForEviction(): OnyxKey | undefined;
+    /**
+     * Set the collection keys for optimized storage
+     */
+    setCollectionKeys(collectionKeys: Set<OnyxKey>): void;
+    /**
+     * Check if a key is a collection key
+     */
+    isCollectionKey(key: OnyxKey): boolean;
+    /**
+     * Get the collection key for a given member key
+     */
+    getCollectionKey(key: OnyxKey): OnyxKey | null;
+    /**
+     * Get all data for a collection key
+     */
+    getCollectionData(collectionKey: OnyxKey): Record<OnyxKey, OnyxValue<OnyxKey>> | undefined;
+    /**
+     * Get all member keys for a collection key
+     */
+    getCollectionMemberKeys(collectionKey: OnyxKey): Set<OnyxKey> | undefined;
 }
 declare const instance: OnyxCache;
 export default instance;

package/dist/OnyxCache.js

@@ -52,13 +52,16 @@ class OnyxCache {
         this.evictionBlocklist = {};
         /** List of keys that have been directly subscribed to or recently modified from least to most recent */
         this.recentlyAccessedKeys = new Set();
+        /** Set of collection keys for fast lookup */
+        this.collectionKeys = new Set();
         this.storageKeys = new Set();
         this.nullishStorageKeys = new Set();
         this.recentKeys = new Set();
         this.storageMap = {};
+        this.collectionIndex = {};
         this.pendingPromises = new Map();
         // bind all public methods to prevent problems with `this`
-        (0, bindAll_1.default)(this, 'getAllKeys', 'get', 'hasCacheForKey', 'addKey', 'addNullishStorageKey', 'hasNullishStorageKey', 'clearNullishStorageKeys', 'set', 'drop', 'merge', 'hasPendingTask', 'getTaskPromise', 'captureTask', 'addToAccessedKeys', 'removeLeastRecentlyUsedKeys', 'setRecentKeysLimit', 'setAllKeys', 'setEvictionAllowList', 'getEvictionBlocklist', 'isEvictableKey', 'removeLastAccessedKey', 'addLastAccessedKey', 'addEvictableKeysToRecentlyAccessedList', 'getKeyForEviction');
+        (0, bindAll_1.default)(this, 'getAllKeys', 'get', 'hasCacheForKey', 'addKey', 'addNullishStorageKey', 'hasNullishStorageKey', 'clearNullishStorageKeys', 'set', 'drop', 'merge', 'hasPendingTask', 'getTaskPromise', 'captureTask', 'addToAccessedKeys', 'removeLeastRecentlyUsedKeys', 'setRecentKeysLimit', 'setAllKeys', 'setEvictionAllowList', 'getEvictionBlocklist', 'isEvictableKey', 'removeLastAccessedKey', 'addLastAccessedKey', 'addEvictableKeysToRecentlyAccessedList', 'getKeyForEviction', 'setCollectionKeys', 'isCollectionKey', 'getCollectionKey', 'getCollectionData', 'getCollectionMemberKeys');
     }
     /** Get all the storage keys */
     getAllKeys() {
@@ -120,16 +123,37 @@ class OnyxCache {
         // When a key is explicitly set in cache, we can remove it from the list of nullish keys,
         // since it will either be set to a non nullish value or removed from the cache completely.
         this.nullishStorageKeys.delete(key);
+        const collectionKey = this.getCollectionKey(key);
         if (value === null || value === undefined) {
             delete this.storageMap[key];
+            // Remove from collection index if it's a collection member
+            if (collectionKey && this.getCollectionMemberKeys(collectionKey)) {
+                this.collectionIndex[collectionKey].delete(key);
+            }
             return undefined;
         }
         this.storageMap[key] = value;
+        // Update collection index if this is a collection member
+        if (collectionKey) {
+            if (!this.getCollectionMemberKeys(collectionKey)) {
+                this.collectionIndex[collectionKey] = new Set();
+            }
+            this.collectionIndex[collectionKey].add(key);
+        }
         return value;
     }
     /** Forget the cached value for the given key */
     drop(key) {
         delete this.storageMap[key];
+        // Update collection index if this is a collection member
+        const collectionKey = this.getCollectionKey(key);
+        if (collectionKey && this.getCollectionMemberKeys(collectionKey)) {
+            this.collectionIndex[collectionKey].delete(key);
+        }
+        // If this is a collection key, clear its index
+        if (this.isCollectionKey(key)) {
+            delete this.collectionIndex[key];
+        }
         this.storageKeys.delete(key);
         this.recentKeys.delete(key);
     }
@@ -145,11 +169,23 @@ class OnyxCache {
         Object.entries(data).forEach(([key, value]) => {
             this.addKey(key);
             this.addToAccessedKeys(key);
+            const collectionKey = this.getCollectionKey(key);
             if (value === null || value === undefined) {
                 this.addNullishStorageKey(key);
+                // Remove from collection index if it's a collection member
+                if (collectionKey && this.getCollectionMemberKeys(collectionKey)) {
+                    this.collectionIndex[collectionKey].delete(key);
+                }
             }
             else {
                 this.nullishStorageKeys.delete(key);
+                // Update collection index if this is a collection member
+                if (collectionKey) {
+                    if (!this.getCollectionMemberKeys(collectionKey)) {
+                        this.collectionIndex[collectionKey] = new Set();
+                    }
+                    this.collectionIndex[collectionKey].add(key);
+                }
             }
         });
     }
@@ -208,6 +244,11 @@ class OnyxCache {
         }
         for (const key of keysToRemove) {
             delete this.storageMap[key];
+            // Update collection index if this is a collection member
+            const collectionKey = this.getCollectionKey(key);
+            if (collectionKey && this.getCollectionMemberKeys(collectionKey)) {
+                this.collectionIndex[collectionKey].delete(key);
+            }
             this.recentKeys.delete(key);
         }
     }
@@ -217,7 +258,8 @@ class OnyxCache {
     }
     /** Check if the value has changed */
     hasValueChanged(key, value) {
-        return !(0, fast_equals_1.deepEqual)(this.storageMap[key], value);
+        const currentValue = this.get(key, false);
+        return !(0, fast_equals_1.deepEqual)(currentValue, value);
     }
     /**
      * Sets the list of keys that are considered safe for eviction
@@ -298,6 +340,59 @@ class OnyxCache {
         }
         return undefined;
     }
+    /**
+     * Set the collection keys for optimized storage
+     */
+    setCollectionKeys(collectionKeys) {
+        this.collectionKeys = collectionKeys;
+        // Initialize collection indexes for existing collection keys
+        collectionKeys.forEach((collectionKey) => {
+            if (this.getCollectionMemberKeys(collectionKey)) {
+                return;
+            }
+            this.collectionIndex[collectionKey] = new Set();
+        });
+    }
+    /**
+     * Check if a key is a collection key
+     */
+    isCollectionKey(key) {
+        return this.collectionKeys.has(key);
+    }
+    /**
+     * Get the collection key for a given member key
+     */
+    getCollectionKey(key) {
+        for (const collectionKey of this.collectionKeys) {
+            if (key.startsWith(collectionKey) && key.length > collectionKey.length) {
+                return collectionKey;
+            }
+        }
+        return null;
+    }
+    /**
+     * Get all data for a collection key
+     */
+    getCollectionData(collectionKey) {
+        const memberKeys = this.getCollectionMemberKeys(collectionKey);
+        if (!memberKeys || memberKeys.size === 0) {
+            return undefined;
+        }
+        const collectionData = {};
+        memberKeys.forEach((memberKey) => {
+            const value = this.storageMap[memberKey];
+            if (value !== undefined) {
+                collectionData[memberKey] = value;
+            }
+        });
+        return collectionData;
+    }
+    /**
+     * Get all member keys for a collection key
+     */
+    getCollectionMemberKeys(collectionKey) {
+        return this.collectionIndex[collectionKey];
+    }
 }
 const instance = new OnyxCache();
 exports.default = instance;

package/dist/OnyxUtils.js

@@ -135,6 +135,8 @@ function initStoreValues(keys, initialKeyStates, evictableKeys, fullyMergedSnaps
     DevTools_1.default.initState(initialKeyStates);
     // Let Onyx know about which keys are safe to evict
     OnyxCache_1.default.setEvictionAllowList(evictableKeys);
+    // Set collection keys in cache for optimized storage
+    OnyxCache_1.default.setCollectionKeys(onyxCollectionKeySet);
     if (typeof keys.COLLECTION === 'object' && typeof keys.COLLECTION.SNAPSHOT === 'string') {
         snapshotKey = keys.COLLECTION.SNAPSHOT;
         fullyMergedSnapshotKeys = new Set(fullyMergedSnapshotKeysParam !== null && fullyMergedSnapshotKeysParam !== void 0 ? fullyMergedSnapshotKeysParam : []);
@@ -428,20 +430,27 @@ function getCollectionKey(key) {
 function tryGetCachedValue(key, mapping) {
     let val = OnyxCache_1.default.get(key);
     if (isCollectionKey(key)) {
+        const collectionData = OnyxCache_1.default.getCollectionData(key);
         const allCacheKeys = OnyxCache_1.default.getAllKeys();
-        // It is possible we haven't loaded all keys yet so we do not know if the
-        // collection actually exists.
-        if (allCacheKeys.size === 0) {
-            return;
+        if (collectionData !== undefined && allCacheKeys.size > 0) {
+            val = collectionData;
         }
-        const values = {};
-        allCacheKeys.forEach((cacheKey) => {
-            if (!cacheKey.startsWith(key)) {
+        else {
+            // Fallback to original logic
+            // It is possible we haven't loaded all keys yet so we do not know if the
+            // collection actually exists.
+            if (allCacheKeys.size === 0) {
                 return;
             }
-            values[cacheKey] = OnyxCache_1.default.get(cacheKey);
-        });
-        val = values;
+            const values = {};
+            allCacheKeys.forEach((cacheKey) => {
+                if (!cacheKey.startsWith(key)) {
+                    return;
+                }
+                values[cacheKey] = OnyxCache_1.default.get(cacheKey);
+            });
+            val = values;
+        }
     }
     if (mapping === null || mapping === void 0 ? void 0 : mapping.selector) {
         const state = mapping.withOnyxInstance ? mapping.withOnyxInstance.state : undefined;
@@ -453,7 +462,27 @@ function tryGetCachedValue(key, mapping) {
     return val;
 }
 function getCachedCollection(collectionKey, collectionMemberKeys) {
+    // Use optimized collection data retrieval when cache is populated
+    const collectionData = OnyxCache_1.default.getCollectionData(collectionKey);
     const allKeys = collectionMemberKeys || OnyxCache_1.default.getAllKeys();
+    if (collectionData !== undefined && (Array.isArray(allKeys) ? allKeys.length > 0 : allKeys.size > 0)) {
+        // If we have specific member keys, filter the collection
+        if (collectionMemberKeys) {
+            const filteredCollection = {};
+            collectionMemberKeys.forEach((key) => {
+                if (collectionData[key] !== undefined) {
+                    filteredCollection[key] = collectionData[key];
+                }
+                else if (OnyxCache_1.default.hasNullishStorageKey(key)) {
+                    filteredCollection[key] = OnyxCache_1.default.get(key);
+                }
+            });
+            return filteredCollection;
+        }
+        // Return a copy to avoid mutations affecting the cache
+        return Object.assign({}, collectionData);
+    }
+    // Fallback to original implementation if collection data not available
     const collection = {};
     // forEach exists on both Set and Array
     allKeys.forEach((key) => {

package/package.json

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