react-native-onyx 3.0.89 → 3.0.90

package/README.md

@@ -257,10 +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: (allReports, collectionKey, sourceValue) => {...});
+Onyx.connect({key: ONYXKEYS.COLLECTION.REPORT}, callback: (allReports, collectionKey) => {...});
 ```
 
-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.
+This will fire the callback once with the entire collection initially and later with an updated version of the collection when individual keys update.
 
 ### Performance Considerations When Using Collections
 

package/dist/OnyxConnectionManager.js

@@ -83,7 +83,7 @@ class OnyxConnectionManager {
         for (const callback of connection.callbacks.values()) {
             try {
                 if (OnyxKeys_1.default.isCollectionKey(connection.onyxKey)) {
-                    callback(connection.cachedCallbackValue, connection.cachedCallbackKey, connection.sourceValue);
+                    callback(connection.cachedCallbackValue, connection.cachedCallbackKey);
                 }
                 else {
                     callback(connection.cachedCallbackValue, connection.cachedCallbackKey);
@@ -107,7 +107,7 @@ class OnyxConnectionManager {
         const callbackID = String(this.lastCallbackID++);
         // If there is no connection yet for that connection ID, we create a new one.
         if (!connectionMetadata) {
-            const callback = (value, key, sourceValue) => {
+            const callback = (value, key) => {
                 const createdConnection = this.connectionsMap.get(connectionID);
                 if (createdConnection) {
                     // We signal that the first connection was made and now any new subscribers
@@ -115,7 +115,6 @@ class OnyxConnectionManager {
                     createdConnection.isConnectionMade = true;
                     createdConnection.cachedCallbackValue = value;
                     createdConnection.cachedCallbackKey = key;
-                    createdConnection.sourceValue = sourceValue;
                     this.fireCallbacks(connectionID);
                 }
             };

package/dist/OnyxUtils.js

@@ -483,7 +483,7 @@ function keysChanged(collectionKey, partialCollection, partialPreviousCollection
         }
         try {
             lastConnectionCallbackData.set(subscriber.subscriptionID, { value: cachedCollection, matchedKey: subscriber.key });
-            subscriber.callback(cachedCollection, subscriber.key, partialCollection);
+            subscriber.callback(cachedCollection, subscriber.key);
         }
         catch (error) {
             Logger.logAlert(`[OnyxUtils.keysChanged] Subscriber callback threw an error for key '${collectionKey}': ${error}`);
@@ -567,7 +567,7 @@ function keyChanged(key, value, canUpdateSubscriber = () => true, isProcessingCo
                         cachedCollections[subscriber.key] = cachedCollection;
                     }
                     lastConnectionCallbackData.set(subscriber.subscriptionID, { value: cachedCollection, matchedKey: subscriber.key });
-                    subscriber.callback(cachedCollection, subscriber.key, { [key]: value });
+                    subscriber.callback(cachedCollection, subscriber.key);
                     continue;
                 }
                 const subscriberCallback = subscriber.callback;

package/dist/types.d.ts

@@ -187,20 +187,20 @@ type BaseConnectOptions = {
 /** Represents the callback function used in `Onyx.connect()` method with a regular key. */
 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;
+type CollectionConnectCallback<TKey extends OnyxKey> = (value: NonUndefined<OnyxCollection<KeyValueMapping[TKey]>>, key: TKey) => void;
 /**
  * Represents the options used in `Onyx.connect()` method.
  *
  * 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
+ * `(collection, key)`). For any other key, the callback fires with the value at
  * that key (signature `(value, key)`).
  */
 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;
+    callback?: (value: TKey extends CollectionKeyBase ? NonUndefined<OnyxCollection<KeyValueMapping[TKey]>> : OnyxEntry<KeyValueMapping[TKey]>, key: TKey) => void;
 };
 type CallbackToStateMapping<TKey extends OnyxKey> = ConnectOptions<TKey> & {
     subscriptionID: number;

package/dist/useOnyx.d.ts

@@ -17,11 +17,10 @@ type UseOnyxOptions<TKey extends OnyxKey, TReturnValue> = {
     selector?: UseOnyxSelector<TKey, TReturnValue>;
 };
 type FetchStatus = 'loading' | 'loaded';
-type ResultMetadata<TValue> = {
+type ResultMetadata = {
     status: FetchStatus;
-    sourceValue?: NonNullable<TValue> | undefined;
 };
-type UseOnyxResult<TValue> = [NonNullable<TValue> | undefined, ResultMetadata<TValue>];
+type UseOnyxResult<TValue> = [NonNullable<TValue> | undefined, ResultMetadata];
 declare function useOnyx<TKey extends OnyxKey, TReturnValue = OnyxValue<TKey>>(key: TKey, options?: UseOnyxOptions<TKey, TReturnValue>, dependencies?: DependencyList): UseOnyxResult<TReturnValue>;
 export default useOnyx;
 export type { FetchStatus, ResultMetadata, UseOnyxResult, UseOnyxOptions, UseOnyxSelector };

package/dist/useOnyx.js

@@ -103,8 +103,6 @@ function useOnyx(key, options, dependencies = []) {
     const onStoreChangeFnRef = (0, react_1.useRef)(null);
     // Indicates if we should get the newest cached value from Onyx during `getSnapshot()` execution.
     const shouldGetCachedValueRef = (0, react_1.useRef)(true);
-    // Inside useOnyx.ts, we need to track the sourceValue separately
-    const sourceValueRef = (0, react_1.useRef)(undefined);
     // Cache the options key to avoid regenerating it every getSnapshot call
     const cacheKey = (0, react_1.useMemo)(() => OnyxSnapshotCache_1.default.registerConsumer(key, {
         selector: options === null || options === void 0 ? void 0 : options.selector,
@@ -191,7 +189,6 @@ function useOnyx(key, options, dependencies = []) {
                 (_c = previousValueRef.current) !== null && _c !== void 0 ? _c : undefined,
                 {
                     status: newFetchStatus,
-                    sourceValue: sourceValueRef.current,
                 },
             ];
         }
@@ -207,7 +204,6 @@ function useOnyx(key, options, dependencies = []) {
         if (hasMountedRef.current) {
             previousValueRef.current = null;
             newValueRef.current = null;
-            sourceValueRef.current = undefined;
             resultRef.current = [undefined, { status: 'loading' }];
             shouldGetCachedValueRef.current = true;
         }
@@ -216,7 +212,7 @@ function useOnyx(key, options, dependencies = []) {
         onStoreChangeFnRef.current = onStoreChange;
         connectionRef.current = OnyxConnectionManager_1.default.connect({
             key,
-            callback: (value, callbackKey, sourceValue) => {
+            callback: () => {
                 isConnectingRef.current = false;
                 onStoreChangeFnRef.current = onStoreChange;
                 // Signals that the first connection was made for this key, so some logics
@@ -224,8 +220,6 @@ function useOnyx(key, options, dependencies = []) {
                 connectedKeyRef.current = key;
                 // Signals that we want to get the newest cached value again in `getSnapshot()`.
                 shouldGetCachedValueRef.current = true;
-                // sourceValue is unknown type, so we need to cast it to the correct type.
-                sourceValueRef.current = sourceValue;
                 // Invalidate snapshot cache for this key when data changes
                 OnyxSnapshotCache_1.default.invalidateForKey(key);
                 // Finally, we signal that the store changed, making `getSnapshot()` be called again.

package/package.json

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