react-native-onyx 2.0.54 → 2.0.56

package/dist/Onyx.js

@@ -97,6 +97,10 @@ function connect(connectOptions) {
     const callbackToStateMapping = OnyxUtils_1.default.getCallbackToStateMapping();
     callbackToStateMapping[connectionID] = mapping;
     callbackToStateMapping[connectionID].connectionID = connectionID;
+    // When keyChanged is called, a key is passed and the method looks through all the Subscribers in callbackToStateMapping for the matching key to get the connectionID
+    // to avoid having to loop through all the Subscribers all the time (even when just one connection belongs to one key),
+    // We create a mapping from key to lists of connectionIDs to access the specific list of connectionIDs.
+    OnyxUtils_1.default.storeKeyByConnections(mapping.key, callbackToStateMapping[connectionID].connectionID);
     if (mapping.initWithStoredValues === false) {
         return connectionID;
     }
@@ -191,6 +195,7 @@ function disconnect(connectionID, keyToRemoveFromEvictionBlocklist) {
     if (keyToRemoveFromEvictionBlocklist) {
         OnyxUtils_1.default.removeFromEvictionBlockList(keyToRemoveFromEvictionBlocklist, connectionID);
     }
+    OnyxUtils_1.default.deleteKeyByConnections(lastConnectionID);
     delete callbackToStateMapping[connectionID];
 }
 /**

package/dist/OnyxUtils.d.ts

@@ -55,6 +55,19 @@ 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>>>;
+/**
+ * Stores a connection ID associated with a given key.
+ *
+ * @param connectionID - a connection ID of the subscriber
+ * @param key - a key that the subscriber is connected to
+ */
+declare function storeKeyByConnections(key: OnyxKey, connectionID: number): void;
+/**
+ * Deletes a connection ID associated with its corresponding key.
+ *
+ * @param {number} connectionID - The connection ID to be deleted.
+ */
+declare function deleteKeyByConnections(connectionID: number): void;
 /** Returns current key names stored in persisted storage */
 declare function getAllKeys(): Promise<Set<OnyxKey>>;
 /**
@@ -76,6 +89,18 @@ declare function splitCollectionMemberKey<TKey extends CollectionKey>(key: TKey)
 declare function isKeyMatch(configKey: OnyxKey, key: OnyxKey): boolean;
 /** Checks to see if this key has been flagged as safe for removal. */
 declare function isSafeEvictionKey(testKey: OnyxKey): boolean;
+/**
+ * It extracts the non-numeric collection identifier of a given key.
+ *
+ * For example:
+ * - `getCollectionKey("report_123")` would return "report_"
+ * - `getCollectionKey("report")` would return "report"
+ * - `getCollectionKey("report_")` would return "report_"
+ *
+ * @param {OnyxKey} key - The key to process.
+ * @return {string} The pure key without any numeric
+ */
+declare function getCollectionKey(key: OnyxKey): string;
 /**
  * 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.
@@ -225,6 +250,7 @@ declare const OnyxUtils: {
     keyChanged: typeof keyChanged;
     sendDataToConnection: typeof sendDataToConnection;
     addKeyToRecentlyAccessedIfNeeded: typeof addKeyToRecentlyAccessedIfNeeded;
+    getCollectionKey: typeof getCollectionKey;
     getCollectionDataAndSendAsObject: typeof getCollectionDataAndSendAsObject;
     scheduleSubscriberUpdate: typeof scheduleSubscriberUpdate;
     scheduleNotifyCollectionSubscribers: typeof scheduleNotifyCollectionSubscribers;
@@ -237,6 +263,8 @@ declare const OnyxUtils: {
     prepareKeyValuePairsForStorage: typeof prepareKeyValuePairsForStorage;
     applyMerge: typeof applyMerge;
     initializeWithDefaultKeyStates: typeof initializeWithDefaultKeyStates;
+    storeKeyByConnections: typeof storeKeyByConnections;
+    deleteKeyByConnections: typeof deleteKeyByConnections;
     getSnapshotKey: typeof getSnapshotKey;
     multiGet: typeof multiGet;
 };

package/dist/OnyxUtils.js

@@ -53,6 +53,8 @@ const mergeQueuePromise = {};
 const callbackToStateMapping = {};
 // Keeps a copy of the values of the onyx collection keys as a map for faster lookups
 let onyxCollectionKeyMap = new Map();
+// Holds a mapping of the connected key to the connectionID for faster lookups
+const onyxKeyToConnectionIDs = new Map();
 // Holds a list of keys that have been directly subscribed to or recently modified from least to most recent
 let recentlyAccessedKeys = [];
 // Holds a list of keys that are safe to remove when we reach max storage. If a key does not match with
@@ -253,6 +255,30 @@ function multiGet(keys) {
         return dataMap;
     }));
 }
+/**
+ * Stores a connection ID associated with a given key.
+ *
+ * @param connectionID - a connection ID of the subscriber
+ * @param key - a key that the subscriber is connected to
+ */
+function storeKeyByConnections(key, connectionID) {
+    if (!onyxKeyToConnectionIDs.has(key)) {
+        onyxKeyToConnectionIDs.set(key, []);
+    }
+    onyxKeyToConnectionIDs.get(key).push(connectionID);
+}
+/**
+ * Deletes a connection ID associated with its corresponding key.
+ *
+ * @param {number} connectionID - The connection ID to be deleted.
+ */
+function deleteKeyByConnections(connectionID) {
+    const subscriber = callbackToStateMapping[connectionID];
+    if (subscriber && onyxKeyToConnectionIDs.has(subscriber.key)) {
+        const updatedConnectionIDs = onyxKeyToConnectionIDs.get(subscriber.key).filter((id) => id !== connectionID);
+        onyxKeyToConnectionIDs.set(subscriber.key, updatedConnectionIDs);
+    }
+}
 /** Returns current key names stored in persisted storage */
 function getAllKeys() {
     // When we've already read stored keys, resolve right away
@@ -289,7 +315,7 @@ function isCollectionMemberKey(collectionKey, key) {
  * @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('_');
+    const underscoreIndex = key.lastIndexOf('_');
     if (underscoreIndex === -1) {
         throw new Error(`Invalid ${key} key provided, only collection keys are allowed.`);
     }
@@ -306,6 +332,24 @@ function isKeyMatch(configKey, key) {
 function isSafeEvictionKey(testKey) {
     return evictionAllowList.some((key) => isKeyMatch(key, testKey));
 }
+/**
+ * It extracts the non-numeric collection identifier of a given key.
+ *
+ * For example:
+ * - `getCollectionKey("report_123")` would return "report_"
+ * - `getCollectionKey("report")` would return "report"
+ * - `getCollectionKey("report_")` would return "report_"
+ *
+ * @param {OnyxKey} key - The key to process.
+ * @return {string} The pure key without any numeric
+ */
+function getCollectionKey(key) {
+    const underscoreIndex = key.lastIndexOf('_');
+    if (underscoreIndex === -1) {
+        return key;
+    }
+    return key.substring(0, underscoreIndex + 1);
+}
 /**
  * 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.
@@ -576,6 +620,7 @@ function keysChanged(collectionKey, partialCollection, partialPreviousCollection
  * keyChanged(key, value, subscriber => subscriber.initWithStoredValues === false)
  */
 function keyChanged(key, value, previousValue, canUpdateSubscriber = () => true, notifyRegularSubscibers = true, notifyWithOnyxSubscibers = true) {
+    var _a, _b;
     // Add or remove this key from the recentlyAccessedKeys lists
     if (value !== null) {
         addLastAccessedKey(key);
@@ -583,10 +628,22 @@ function keyChanged(key, value, previousValue, canUpdateSubscriber = () => true,
     else {
         removeLastAccessedKey(key);
     }
-    // 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
+    // We get the subscribers 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 = Object.keys(callbackToStateMapping);
+    // Given the amount of times this function is called we need to make sure we are not iterating over all subscribers every time. On the other hand, we don't need to
+    // do the same in keysChanged, because we only call that function when a collection key changes, and it doesn't happen that often.
+    // For performance reason, we look for the given key and later if don't find it we look for the collection key, instead of checking if it is a collection key first.
+    let stateMappingKeys = (_a = onyxKeyToConnectionIDs.get(key)) !== null && _a !== void 0 ? _a : [];
+    const collectionKey = getCollectionKey(key);
+    const plainCollectionKey = collectionKey.lastIndexOf('_') !== -1 ? collectionKey : undefined;
+    if (plainCollectionKey) {
+        // Getting the collection key from the specific key because only collection keys were stored in the mapping.
+        stateMappingKeys = [...stateMappingKeys, ...((_b = onyxKeyToConnectionIDs.get(plainCollectionKey)) !== null && _b !== void 0 ? _b : [])];
+        if (stateMappingKeys.length === 0) {
+            return;
+        }
+    }
     for (let i = 0; i < stateMappingKeys.length; i++) {
         const subscriber = callbackToStateMapping[stateMappingKeys[i]];
         if (!subscriber || !isKeyMatch(subscriber.key, key) || !canUpdateSubscriber(subscriber)) {
@@ -926,6 +983,7 @@ const OnyxUtils = {
     keyChanged,
     sendDataToConnection,
     addKeyToRecentlyAccessedIfNeeded,
+    getCollectionKey,
     getCollectionDataAndSendAsObject,
     scheduleSubscriberUpdate,
     scheduleNotifyCollectionSubscribers,
@@ -938,6 +996,8 @@ const OnyxUtils = {
     prepareKeyValuePairsForStorage,
     applyMerge,
     initializeWithDefaultKeyStates,
+    storeKeyByConnections,
+    deleteKeyByConnections,
     getSnapshotKey,
     multiGet,
 };

package/dist/useOnyx.js

@@ -86,12 +86,11 @@ function useOnyx(key, options) {
             newValueRef.current = ((_a = options === null || options === void 0 ? void 0 : options.initialValue) !== null && _a !== void 0 ? _a : undefined);
             newFetchStatus = 'loaded';
         }
-        // We do a deep equality check if we are subscribed to a collection key and `selector` is defined,
-        // since each `OnyxUtils.tryGetCachedValue()` call will generate a plain new collection object with new records as well,
-        // all of them created using the `selector` function.
+        // We do a deep equality check if `selector` is defined, since each `OnyxUtils.tryGetCachedValue()` call will
+        // generate a plain new primitive/object/array that was created using the `selector` function.
         // For the other cases we will only deal with object reference checks, so just a shallow equality check is enough.
         let areValuesEqual;
-        if (OnyxUtils_1.default.isCollectionKey(key) && selectorRef.current) {
+        if (selectorRef.current) {
             areValuesEqual = (0, fast_equals_1.deepEqual)((_b = previousValueRef.current) !== null && _b !== void 0 ? _b : undefined, newValueRef.current);
         }
         else {

package/package.json

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