react-native-onyx 3.0.88 → 3.0.89

package/API.md

@@ -80,7 +80,6 @@ This method will be deprecated soon. Please use `Onyx.connectWithoutView()` inst
 | connectOptions | The options object that will define the behavior of the connection. |
 | connectOptions.key | The Onyx key to subscribe to. |
 | connectOptions.callback | A function that will be called when the Onyx data we are subscribed changes. |
-| connectOptions.waitForCollectionCallback | If set to `true`, it will return the entire collection to the callback as a single object. |
 | connectOptions.selector | This will be used to subscribe to a subset of an Onyx key's data. **Only used inside `useOnyx()` hook.**        Using this setting on `useOnyx()` 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). |
 
 **Example**  
@@ -103,7 +102,6 @@ Connects to an Onyx key given the options passed and listens to its changes.
 | connectOptions | The options object that will define the behavior of the connection. |
 | connectOptions.key | The Onyx key to subscribe to. |
 | connectOptions.callback | A function that will be called when the Onyx data we are subscribed changes. |
-| connectOptions.waitForCollectionCallback | If set to `true`, it will return the entire collection to the callback as a single object. |
 | connectOptions.selector | This will be used to subscribe to a subset of an Onyx key's data. **Only used inside `useOnyx()` hook.**        Using this setting on `useOnyx()` 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). |
 
 **Example**  

package/README.md

@@ -257,20 +257,10 @@ export default MyComponent;
 This will add a prop to the component called `allReports` which is an object of collection member key/values. Changes to the individual member keys will modify the entire object and new props will be passed with each individual key update. The prop doesn't update on the initial rendering of the component until the entire collection has been read out of Onyx.
 
 ```js
-Onyx.connect({key: ONYXKEYS.COLLECTION.REPORT}, callback: (memberValue, memberKey) => {...});
+Onyx.connect({key: ONYXKEYS.COLLECTION.REPORT}, callback: (allReports, collectionKey, sourceValue) => {...});
 ```
 
-This will fire the callback once per member key depending on how many collection member keys are currently stored. Changes to those keys after the initial callbacks fire will occur when each individual key is updated.
-
-```js
-Onyx.connect({
-    key: ONYXKEYS.COLLECTION.REPORT,
-    waitForCollectionCallback: true,
-    callback: (allReports, collectionKey, sourceValue) => {...},
-});
-```
-
-This final option forces `Onyx.connect()` to behave more like `useOnyx()` and only update the callback once with the entire collection initially and later with an updated version of the collection when individual keys update. The `sourceValue` parameter contains only the specific keys and values that triggered the current update, which can be useful for optimizing your code to only process what changed. This parameter is not available when `waitForCollectionCallback` is false or the key is not a collection key.
+This will fire the callback once with the entire collection initially and later with an updated version of the collection when individual keys update. The `sourceValue` parameter contains only the specific keys and values that triggered the current update, which can be useful for optimizing your code to only process what changed.
 
 ### Performance Considerations When Using Collections
 

package/dist/Onyx.d.ts

@@ -18,7 +18,6 @@ declare function init({ keys, initialKeyStates, evictableKeys, shouldSyncMultipl
  * @param connectOptions The options object that will define the behavior of the connection.
  * @param connectOptions.key The Onyx key to subscribe to.
  * @param connectOptions.callback A function that will be called when the Onyx data we are subscribed changes.
- * @param connectOptions.waitForCollectionCallback If set to `true`, it will return the entire collection to the callback as a single object.
  * @param connectOptions.selector This will be used to subscribe to a subset of an Onyx key's data. **Only used inside `useOnyx()` hook.**
  *        Using this setting on `useOnyx()` 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
@@ -40,7 +39,6 @@ declare function connect<TKey extends OnyxKey>(connectOptions: ConnectOptions<TK
  * @param connectOptions The options object that will define the behavior of the connection.
  * @param connectOptions.key The Onyx key to subscribe to.
  * @param connectOptions.callback A function that will be called when the Onyx data we are subscribed changes.
- * @param connectOptions.waitForCollectionCallback If set to `true`, it will return the entire collection to the callback as a single object.
  * @param connectOptions.selector This will be used to subscribe to a subset of an Onyx key's data. **Only used inside `useOnyx()` hook.**
  *        Using this setting on `useOnyx()` 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

package/dist/Onyx.js

@@ -93,7 +93,6 @@ function init({ keys = {}, initialKeyStates = {}, evictableKeys = [], shouldSync
  * @param connectOptions The options object that will define the behavior of the connection.
  * @param connectOptions.key The Onyx key to subscribe to.
  * @param connectOptions.callback A function that will be called when the Onyx data we are subscribed changes.
- * @param connectOptions.waitForCollectionCallback If set to `true`, it will return the entire collection to the callback as a single object.
  * @param connectOptions.selector This will be used to subscribe to a subset of an Onyx key's data. **Only used inside `useOnyx()` hook.**
  *        Using this setting on `useOnyx()` 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
@@ -117,7 +116,6 @@ function connect(connectOptions) {
  * @param connectOptions The options object that will define the behavior of the connection.
  * @param connectOptions.key The Onyx key to subscribe to.
  * @param connectOptions.callback A function that will be called when the Onyx data we are subscribed changes.
- * @param connectOptions.waitForCollectionCallback If set to `true`, it will return the entire collection to the callback as a single object.
  * @param connectOptions.selector This will be used to subscribe to a subset of an Onyx key's data. **Only used inside `useOnyx()` hook.**
  *        Using this setting on `useOnyx()` 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

package/dist/OnyxConnectionManager.js

@@ -60,18 +60,17 @@ class OnyxConnectionManager {
      * according to their purpose and effect they produce in the Onyx connection.
      */
     generateConnectionID(connectOptions) {
-        const { key, reuseConnection, waitForCollectionCallback } = connectOptions;
+        const { key, reuseConnection } = connectOptions;
         // The current session ID is appended to the connection ID so we can have different connections
         // after an `Onyx.clear()` operation.
         let suffix = `,sessionID=${this.sessionID}`;
-        // We will generate a unique ID in any of the following situations:
-        // - `reuseConnection` is `false`. That means the subscriber explicitly wants the connection to not be reused.
-        // - `key` is a collection key AND `waitForCollectionCallback` is `undefined/false`. This combination needs a new connection at every subscription
-        //   in order to send all the collection entries, so the connection can't be reused.
-        if (reuseConnection === false || (OnyxKeys_1.default.isCollectionKey(key) && (waitForCollectionCallback === undefined || waitForCollectionCallback === false))) {
+        // We will generate a unique ID when `reuseConnection` is `false`, which means the subscriber
+        // explicitly wants the connection to not be reused. Collection-root subscriptions are now always
+        // snapshot mode, so they can be reused like any other connection.
+        if (reuseConnection === false) {
             suffix += `,uniqueID=${Str.guid()}`;
         }
-        return `onyxKey=${key},waitForCollectionCallback=${waitForCollectionCallback !== null && waitForCollectionCallback !== void 0 ? waitForCollectionCallback : false}${suffix}`;
+        return `onyxKey=${key}${suffix}`;
     }
     /**
      * Fires all the subscribers callbacks associated with that connection ID.
@@ -82,11 +81,16 @@ class OnyxConnectionManager {
             return;
         }
         for (const callback of connection.callbacks.values()) {
-            if (connection.waitForCollectionCallback) {
-                callback(connection.cachedCallbackValue, connection.cachedCallbackKey, connection.sourceValue);
+            try {
+                if (OnyxKeys_1.default.isCollectionKey(connection.onyxKey)) {
+                    callback(connection.cachedCallbackValue, connection.cachedCallbackKey, connection.sourceValue);
+                }
+                else {
+                    callback(connection.cachedCallbackValue, connection.cachedCallbackKey);
+                }
             }
-            else {
-                callback(connection.cachedCallbackValue, connection.cachedCallbackKey);
+            catch (error) {
+                Logger.logAlert(`[ConnectionManager] Subscriber callback threw an error for key '${connection.onyxKey}': ${error}`);
             }
         }
     }
@@ -115,13 +119,12 @@ class OnyxConnectionManager {
                     this.fireCallbacks(connectionID);
                 }
             };
-            subscriptionID = OnyxUtils_1.default.subscribeToKey(Object.assign(Object.assign({}, connectOptions), { callback: callback }));
+            subscriptionID = OnyxUtils_1.default.subscribeToKey(Object.assign(Object.assign({}, connectOptions), { callback }));
             connectionMetadata = {
                 subscriptionID,
                 onyxKey: connectOptions.key,
                 isConnectionMade: false,
                 callbacks: new Map(),
-                waitForCollectionCallback: connectOptions.waitForCollectionCallback,
             };
             this.connectionsMap.set(connectionID, connectionMetadata);
         }
@@ -134,8 +137,8 @@ class OnyxConnectionManager {
             // Defer the callback execution to the next tick of the event loop.
             // This ensures that the current execution flow completes and the result connection object is available when the callback fires.
             Promise.resolve().then(() => {
-                var _a, _b;
-                (_b = (_a = connectOptions).callback) === null || _b === void 0 ? void 0 : _b.call(_a, connectionMetadata.cachedCallbackValue, connectionMetadata.cachedCallbackKey);
+                var _a;
+                (_a = connectOptions.callback) === null || _a === void 0 ? void 0 : _a.call(connectOptions, connectionMetadata.cachedCallbackValue, connectionMetadata.cachedCallbackKey);
             });
         }
         return { id: connectionID, callbackID };

package/dist/OnyxUtils.js

@@ -482,29 +482,8 @@ function keysChanged(collectionKey, partialCollection, partialPreviousCollection
             continue;
         }
         try {
-            lastConnectionCallbackData.set(subscriber.subscriptionID, {
-                value: cachedCollection,
-                matchedKey: subscriber.key,
-            });
-            if (subscriber.waitForCollectionCallback) {
-                subscriber.callback(cachedCollection, subscriber.key, partialCollection);
-                continue;
-            }
-            // Not using waitForCollectionCallback — notify per changed key.
-            // Re-check the subscription on each iteration because the callback may
-            // synchronously disconnect itself (removing it from callbackToStateMapping),
-            // in which case we must stop firing further callbacks for this subscriber.
-            for (const dataKey of changedMemberKeys) {
-                const currentSubscriber = callbackToStateMapping[subID];
-                if (!currentSubscriber || typeof currentSubscriber.callback !== 'function') {
-                    break;
-                }
-                if (cachedCollection[dataKey] === previousCollection[dataKey]) {
-                    continue;
-                }
-                const currentSubscriberCallback = currentSubscriber.callback;
-                currentSubscriberCallback(cachedCollection[dataKey], dataKey);
-            }
+            lastConnectionCallbackData.set(subscriber.subscriptionID, { value: cachedCollection, matchedKey: subscriber.key });
+            subscriber.callback(cachedCollection, subscriber.key, partialCollection);
         }
         catch (error) {
             Logger.logAlert(`[OnyxUtils.keysChanged] Subscriber callback threw an error for key '${collectionKey}': ${error}`);
@@ -574,9 +553,9 @@ function keyChanged(key, value, canUpdateSubscriber = () => true, isProcessingCo
                 if (lastData && lastData.matchedKey === key && lastData.value === value) {
                     continue;
                 }
-                if (OnyxKeys_1.default.isCollectionKey(subscriber.key) && subscriber.waitForCollectionCallback) {
-                    // Skip individual key changes for collection callbacks during collection updates
-                    // to prevent duplicate callbacks - the collection update will handle this properly
+                if (OnyxKeys_1.default.isCollectionKey(subscriber.key)) {
+                    // Skip individual key changes during collection updates to prevent duplicate
+                    // callbacks - the collection update will handle this properly.
                     if (isProcessingCollectionUpdate) {
                         continue;
                     }
@@ -587,13 +566,8 @@ function keyChanged(key, value, canUpdateSubscriber = () => true, isProcessingCo
                         cachedCollection = getCachedCollection(subscriber.key);
                         cachedCollections[subscriber.key] = cachedCollection;
                     }
-                    lastConnectionCallbackData.set(subscriber.subscriptionID, {
-                        value: cachedCollection,
-                        matchedKey: subscriber.key,
-                    });
-                    subscriber.callback(cachedCollection, subscriber.key, {
-                        [key]: value,
-                    });
+                    lastConnectionCallbackData.set(subscriber.subscriptionID, { value: cachedCollection, matchedKey: subscriber.key });
+                    subscriber.callback(cachedCollection, subscriber.key, { [key]: value });
                     continue;
                 }
                 const subscriberCallback = subscriber.callback;
@@ -616,17 +590,17 @@ function keyChanged(key, value, canUpdateSubscriber = () => true, isProcessingCo
  * Sends the data obtained from the keys to the connection.
  */
 function sendDataToConnection(mapping, matchedKey) {
-    var _a, _b;
+    var _a;
     // If the mapping no longer exists then we should not send any data.
     // This means our subscriber was disconnected.
     if (!callbackToStateMapping[mapping.subscriptionID]) {
         return;
     }
     // Always read the latest value from cache to avoid stale or duplicate data.
-    // For collection subscribers with waitForCollectionCallback, read the full collection.
+    // For collection-root subscribers, read the full collection.
     // For individual key subscribers, read just that key's value.
     let value;
-    if (OnyxKeys_1.default.isCollectionKey(mapping.key) && mapping.waitForCollectionCallback) {
+    if (OnyxKeys_1.default.isCollectionKey(mapping.key)) {
         const collection = getCachedCollection(mapping.key);
         value = Object.keys(collection).length > 0 ? collection : undefined;
     }
@@ -642,7 +616,7 @@ function sendDataToConnection(mapping, matchedKey) {
     if (lastData && lastData.matchedKey === matchedKey && (0, fast_equals_1.shallowEqual)(lastData.value, value)) {
         return;
     }
-    (_b = (_a = mapping).callback) === null || _b === void 0 ? void 0 : _b.call(_a, value, matchedKey);
+    (_a = mapping.callback) === null || _a === void 0 ? void 0 : _a.call(mapping, value, matchedKey);
 }
 /**
  * Gets the data for a given an array of matching keys, combines them into an object, and sends the result back to the subscriber.
@@ -984,27 +958,17 @@ function subscribeToKey(connectOptions) {
             if (mapping.key) {
                 OnyxCache_1.default.addNullishStorageKey(mapping.key);
             }
-            const matchedKey = OnyxKeys_1.default.isCollectionKey(mapping.key) && mapping.waitForCollectionCallback ? mapping.key : undefined;
+            const matchedKey = OnyxKeys_1.default.isCollectionKey(mapping.key) ? mapping.key : undefined;
             // Here we cannot use batching because the nullish value is expected to be set immediately for default props
             // or they will be undefined.
             sendDataToConnection(mapping, matchedKey);
             return;
         }
-        // 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.
+        // When using a callback subscriber, a subscription to a collection key combines all matching
+        // member values into a single object and makes one call with the whole collection object.
         if (typeof mapping.callback === 'function') {
             if (OnyxKeys_1.default.isCollectionKey(mapping.key)) {
-                if (mapping.waitForCollectionCallback) {
-                    getCollectionDataAndSendAsObject(matchingKeys, mapping);
-                    return;
-                }
-                // We did not opt into using waitForCollectionCallback mode so the callback is called for every matching key.
-                multiGet(matchingKeys).then(() => {
-                    for (const key of matchingKeys) {
-                        sendDataToConnection(mapping, key);
-                    }
-                });
+                getCollectionDataAndSendAsObject(matchingKeys, mapping);
                 return;
             }
             // If we are not subscribed to a collection key then there's only a single key to send an update for.
@@ -1217,7 +1181,7 @@ function multiSetWithRetry(data, retryAttempt) {
             // and subscriber state, matching the original per-key notification semantics.
             OnyxCache_1.default.set(key, value);
             // Skip subscriber notification on retry — already notified on attempt 0.
-            // waitForCollectionCallback subscribers re-fire on every keyChanged by contract.
+            // Collection-root subscribers re-fire on every keyChanged by contract.
             if (!retryAttempt) {
                 keyChanged(key, value);
             }
@@ -1296,7 +1260,7 @@ function setCollectionWithRetry({ collectionKey, collection }, retryAttempt) {
         for (const [key, value] of keyValuePairs)
             OnyxCache_1.default.set(key, value);
         // Skip subscriber notification on retry — already notified on attempt 0.
-        // waitForCollectionCallback subscribers re-fire on every keysChanged by contract.
+        // Collection-root subscribers re-fire on every keysChanged by contract.
         if (!retryAttempt) {
             keysChanged(collectionKey, mutableCollection, previousCollection);
         }
@@ -1419,7 +1383,7 @@ function mergeCollectionWithPatches({ collectionKey, collection, mergeReplaceNul
             const previousCollection = getCachedCollection(collectionKey, existingKeys);
             OnyxCache_1.default.merge(finalMergedCollection);
             // Skip subscriber notification on retry — already notified on attempt 0.
-            // waitForCollectionCallback subscribers re-fire on every keysChanged by contract.
+            // Collection-root subscribers re-fire on every keysChanged by contract.
             if (!retryAttempt) {
                 keysChanged(collectionKey, finalMergedCollection, previousCollection);
             }
@@ -1494,7 +1458,7 @@ function partialSetCollection({ collectionKey, collection }, retryAttempt) {
         for (const [key, value] of keyValuePairs)
             OnyxCache_1.default.set(key, value);
         // Skip subscriber notification on retry — already notified on attempt 0.
-        // waitForCollectionCallback subscribers re-fire on every keysChanged by contract.
+        // Collection-root subscribers re-fire on every keysChanged by contract.
         if (!retryAttempt) {
             keysChanged(collectionKey, mutableCollection, previousCollection);
         }

package/dist/types.d.ts

@@ -188,36 +188,20 @@ type BaseConnectOptions = {
 type DefaultConnectCallback<TKey extends OnyxKey> = (value: OnyxEntry<KeyValueMapping[TKey]>, key: TKey) => void;
 /** Represents the callback function used in `Onyx.connect()` method with a collection key. */
 type CollectionConnectCallback<TKey extends OnyxKey> = (value: NonUndefined<OnyxCollection<KeyValueMapping[TKey]>>, key: TKey, sourceValue?: OnyxValue<TKey>) => void;
-/** Represents the options used in `Onyx.connect()` method with a regular key. */
-type DefaultConnectOptions<TKey extends OnyxKey> = BaseConnectOptions & {
-    /** The Onyx key to subscribe to. */
-    key: TKey;
-    /** A function that will be called when the Onyx data we are subscribed changes. */
-    callback?: DefaultConnectCallback<TKey>;
-    /** If set to `true`, it will return the entire collection to the callback as a single object. */
-    waitForCollectionCallback?: false;
-};
-/** Represents the options used in `Onyx.connect()` method with a collection key. */
-type CollectionConnectOptions<TKey extends OnyxKey> = BaseConnectOptions & {
-    /** The Onyx key to subscribe to. */
-    key: TKey extends CollectionKeyBase ? TKey : never;
-    /** A function that will be called when the Onyx data we are subscribed changes. */
-    callback?: CollectionConnectCallback<TKey>;
-    /** If set to `true`, it will return the entire collection to the callback as a single object. */
-    waitForCollectionCallback: true;
-};
 /**
  * Represents the options used in `Onyx.connect()` method.
- * The type is built from `DefaultConnectOptions`/`CollectionConnectOptions` depending on the `waitForCollectionCallback` property.
- * It includes two different forms, depending on whether we are waiting for a collection callback or not.
- *
- * If `waitForCollectionCallback` is `true`, it expects `key` to be a Onyx collection key and `callback` will be triggered with the whole collection
- * and will pass `value` as an `OnyxCollection`.
  *
- * If `waitForCollectionCallback` is `false` or not specified, the `key` can be any Onyx key and `callback` will be triggered with updates of each collection item
- * and will pass `value` as an `OnyxEntry`.
+ * For a collection root key (e.g. `ONYXKEYS.COLLECTION.REPORT`), the callback fires
+ * with the entire collection object whenever any member changes (signature
+ * `(collection, key, sourceValue)`). For any other key, the callback fires with the value at
+ * that key (signature `(value, key)`).
  */
-type ConnectOptions<TKey extends OnyxKey> = DefaultConnectOptions<TKey> | CollectionConnectOptions<TKey>;
+type ConnectOptions<TKey extends OnyxKey> = BaseConnectOptions & {
+    /** The Onyx key to subscribe to. */
+    key: TKey;
+    /** A function that will be called when the Onyx data we are subscribed changes. */
+    callback?: (value: TKey extends CollectionKeyBase ? NonUndefined<OnyxCollection<KeyValueMapping[TKey]>> : OnyxEntry<KeyValueMapping[TKey]>, key: TKey, sourceValue?: TKey extends CollectionKeyBase ? NonUndefined<OnyxCollection<KeyValueMapping[TKey]>> : never) => void;
+};
 type CallbackToStateMapping<TKey extends OnyxKey> = ConnectOptions<TKey> & {
     subscriptionID: number;
 };
@@ -379,4 +363,4 @@ type MixedOperationsQueue = {
     mergeReplaceNullPatches: MultiMergeReplaceNullPatches;
     set: OnyxInputKeyValueMapping;
 };
-export type { BaseConnectOptions, Collection, CollectionConnectCallback, CollectionConnectOptions, CollectionKey, CollectionKeyBase, ConnectOptions, CustomTypeOptions, DeepRecord, DefaultConnectCallback, DefaultConnectOptions, ExtractOnyxCollectionValue, GenericFunction, InitOptions, Key, KeyValueMapping, CallbackToStateMapping, NonNull, NonUndefined, OnyxInputKeyValueMapping, NullishDeep, OnyxCollection, OnyxEntry, OnyxKey, OnyxInputValue, OnyxCollectionInputValue, OnyxInput, OnyxSetInput, OnyxMultiSetInput, OnyxMergeInput, OnyxMergeCollectionInput, OnyxSetCollectionInput, OnyxMethod, OnyxMethodMap, OnyxUpdate, OnyxValue, Selector, SetOptions, SetParams, SetCollectionParams, MergeCollectionWithPatchesParams, MultiMergeReplaceNullPatches, MixedOperationsQueue, RetriableOnyxOperation, };
+export type { BaseConnectOptions, Collection, CollectionConnectCallback, CollectionKey, CollectionKeyBase, ConnectOptions, CustomTypeOptions, DeepRecord, DefaultConnectCallback, ExtractOnyxCollectionValue, GenericFunction, InitOptions, Key, KeyValueMapping, CallbackToStateMapping, NonNull, NonUndefined, OnyxInputKeyValueMapping, NullishDeep, OnyxCollection, OnyxEntry, OnyxKey, OnyxInputValue, OnyxCollectionInputValue, OnyxInput, OnyxSetInput, OnyxMultiSetInput, OnyxMergeInput, OnyxMergeCollectionInput, OnyxSetCollectionInput, OnyxMethod, OnyxMethodMap, OnyxUpdate, OnyxValue, Selector, SetOptions, SetParams, SetCollectionParams, MergeCollectionWithPatchesParams, MultiMergeReplaceNullPatches, MixedOperationsQueue, RetriableOnyxOperation, };

package/dist/useOnyx.js

@@ -41,7 +41,6 @@ const react_1 = require("react");
 const OnyxCache_1 = __importStar(require("./OnyxCache"));
 const OnyxConnectionManager_1 = __importDefault(require("./OnyxConnectionManager"));
 const OnyxUtils_1 = __importDefault(require("./OnyxUtils"));
-const OnyxKeys_1 = __importDefault(require("./OnyxKeys"));
 const OnyxSnapshotCache_1 = __importDefault(require("./OnyxSnapshotCache"));
 const useLiveRef_1 = __importDefault(require("./useLiveRef"));
 function useOnyx(key, options, dependencies = []) {
@@ -232,7 +231,6 @@ function useOnyx(key, options, dependencies = []) {
                 // Finally, we signal that the store changed, making `getSnapshot()` be called again.
                 onStoreChange();
             },
-            waitForCollectionCallback: OnyxKeys_1.default.isCollectionKey(key),
             reuseConnection: options === null || options === void 0 ? void 0 : options.reuseConnection,
         });
         return () => {

package/package.json

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