react-native-onyx 2.0.141 → 3.0.2

package/API.md

@@ -81,10 +81,7 @@ This method will be deprecated soon. Please use `Onyx.connectWithoutView()` inst
 | 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.withOnyxInstance | The `withOnyx` class instance to be internally passed. **Only used inside `withOnyx()` HOC.** |
-| connectOptions.statePropertyName | The name of the component's prop that is connected to the Onyx key. **Only used inside `withOnyx()` HOC.** |
-| connectOptions.displayName | The component's display name. **Only used inside `withOnyx()` HOC.** |
-| connectOptions.selector | This will be used to subscribe to a subset of an Onyx key's data. **Only used inside `useOnyx()` hook or `withOnyx()` HOC.**        Using this setting on `useOnyx()` or `withOnyx()` 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). |
+| 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**  
 ```ts
@@ -107,10 +104,7 @@ Connects to an Onyx key given the options passed and listens to its changes.
 | 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.withOnyxInstance | The `withOnyx` class instance to be internally passed. **Only used inside `withOnyx()` HOC.** |
-| connectOptions.statePropertyName | The name of the component's prop that is connected to the Onyx key. **Only used inside `withOnyx()` HOC.** |
-| connectOptions.displayName | The component's display name. **Only used inside `withOnyx()` HOC.** |
-| connectOptions.selector | This will be used to subscribe to a subset of an Onyx key's data. **Only used inside `useOnyx()` hook or `withOnyx()` HOC.**        Using this setting on `useOnyx()` or `withOnyx()` 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). |
+| 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**  
 ```ts

package/README.md

@@ -9,7 +9,7 @@ Awesome persistent storage solution wrapped in a Pub/Sub library.
 - Onyx allows other code to subscribe to changes in data, and then publishes change events whenever data is changed
 - Anything needing to read Onyx data needs to:
     1. Know what key the data is stored in (for web, you can find this by looking in the JS console > Application > local storage)
-    2. Subscribe to changes of the data for a particular key or set of keys. React function components use the `useOnyx()` hook (recommended), both class and function components can use `withOnyx()` HOC (deprecated, not-recommended) and non-React libs use `Onyx.connect()`.
+    2. Subscribe to changes of the data for a particular key or set of keys. React function components use the `useOnyx()` hook and non-React libs use `Onyx.connect()`.
     3. Get initialized with the current value of that key from persistent storage (Onyx does this by calling `setState()` or triggering the `callback` with the values currently on disk as part of the connection process)
 - Subscribing to Onyx keys is done using a constant defined in `ONYXKEYS`. Each Onyx key represents either a collection of items or a specific entry in storage. For example, since all reports are stored as individual keys like `report_1234`, if code needs to know about all the reports (e.g. display a list of them in the nav menu), then it would subscribe to the key `ONYXKEYS.COLLECTION.REPORT`.
 
@@ -136,7 +136,7 @@ To teardown the subscription call `Onyx.disconnect()` with the `connectionID` re
 Onyx.disconnect(connectionID);
 ```
 
-We can also access values inside React function components via the `useOnyx()` [hook](https://react.dev/reference/react/hooks) (recommended) or class and function components via the `withOnyx()` [higher order component](https://reactjs.org/docs/higher-order-components.html) (deprecated, not-recommended). When the data changes the component will re-render.
+We can also access values inside React function components via the `useOnyx()` [hook](https://react.dev/reference/react/hooks). When the data changes the component will re-render.
 
 ```javascript
 import React from 'react';
@@ -168,48 +168,6 @@ if (reportsResult.status === 'loading' || sessionResult.status === 'loading') {
 // rest of the component's code.
 ```
 
-> [!warning]
-> ## Deprecated Note
-> Please note that the `withOnyx()` Higher Order Component (HOC) is now considered deprecated. Use `useOnyx()` hook instead.
-
-```javascript
-import React from 'react';
-import {withOnyx} from 'react-native-onyx';
-
-const App = ({session}) => (
-    <View>
-        {session.token ? <Text>Logged in</Text> : <Text>Logged out</Text> }
-    </View>
-);
-
-export default withOnyx({
-    session: {
-        key: ONYXKEYS.SESSION,
-    },
-})(App);
-```
-
-Differently from `useOnyx()`, `withOnyx()` will delay the rendering of the wrapped component until all keys/entities have been fetched and passed to the component, this can be convenient for simple cases. This however, can really delay your application if many entities are connected to the same component.
-
-Additionally, if your component has many keys/entities when your component will mount but will receive many updates as data is fetched from DB and passed down to it, as every key that gets fetched will trigger a `setState` on the `withOnyx` HOC. This might cause re-renders on the initial mounting, preventing the component from mounting/rendering in reasonable time, making your app feel slow and even delaying animations.
-
-You can workaround this by passing an additional object with the `shouldDelayUpdates` property set to true. Onyx will then put all the updates in a queue until you decide when then should be applied, the component will receive a function `markReadyForHydration`. A good place to call this function is on the `onLayout` method, which gets triggered after your component has been rendered.
-
-```javascript
-const App = ({session, markReadyForHydration}) => (
-    <View onLayout={() => markReadyForHydration()}>
-        {session.token ? <Text>Logged in</Text> : <Text>Logged out</Text> }
-    </View>
-);
-
-// Second argument to funciton is `shouldDelayUpdates`
-export default withOnyx({
-    session: {
-        key: ONYXKEYS.SESSION
-    },
-}, true)(App);
-```
-
 ### Dependent Onyx Keys and useOnyx()
 Some components need to subscribe to multiple Onyx keys at once and sometimes, one key might rely on the data from another key. This is similar to a JOIN in SQL.
 
@@ -246,24 +204,6 @@ export default App;
   
 * It is VERY important to NOT use empty string default values like `report.policyID || ''`. This results in the key returned to `useOnyx` as `policies_`, which subscribes to the ENTIRE POLICY COLLECTION and is most assuredly not what you were intending. You can use a default of `0` (as long as you are reasonably sure that there is never a policyID=0). This allows Onyx to return `undefined` as the value of the policy key, which is handled by `useOnyx` appropriately.
 
-**Detailed explanation of how this is handled and rendered with `withOnyx` HOC:**
-1. The component mounts with a `reportID={1234}` prop
-2. `withOnyx` evaluates the mapping
-3. `withOnyx` connects to the key `reports_1234` because of the prop passed to the component
-3. `withOnyx` connects to the key `policies_undefined` because `report` doesn't exist in the props yet, so the `policyID` defaults to `undefined`. * (see note below)
-4. Onyx reads the data and updates the state of `withOnyx` with:
-    - `report={{reportID: 1234, policyID: 1, ... the rest of the object ...}}`
-    - `policy={undefined}` (since there is no policy with ID `undefined`)
-5. There is still an `undefined` key in the mapping, so Onyx reads the data again
-6. This time `withOnyx` connects to the key `policies_1` because the `report` object exists in the component's state and it has a `policyID: 1`
-7. Onyx reads the data and updates the state of withOnyx with:
-    - `policy={{policyID: 1, ... the rest of the object ...}`
-8. Now all mappings have values that are defined (not undefined) and the component is rendered with all necessary data
-  
-* It is VERY important to NOT use empty string default values like `report.policyID || ''`. This results in the key returned to `withOnyx` as `policies_` which subscribes to the ENTIRE POLICY COLLECTION and is most assuredly not what you were intending. You can use a default of `0` (as long as you are reasonably sure that there is never a policyID=0). This allows Onyx to return `undefined` as the value of the policy key, which is handled by `withOnyx` appropriately.
-
-DO NOT use more than one `withOnyx` component at a time. It adds overhead and prevents some optimizations like batched rendering from working to its full potential.
-
 It's also beneficial to use a [selector](https://github.com/Expensify/react-native-onyx/blob/main/API.md#connectmapping--number) with the mapping in case you need to grab a single item in a collection (like a single report action).
 
 ### useOnyx()'s `canBeMissing` option

package/dist/Onyx.d.ts

@@ -1,8 +1,8 @@
 import * as Logger from './Logger';
-import type { CollectionKeyBase, ConnectOptions, InitOptions, Mapping, OnyxKey, OnyxMergeCollectionInput, OnyxMergeInput, OnyxMultiSetInput, OnyxSetInput, OnyxUpdate, SetOptions } from './types';
+import type { CollectionKeyBase, ConnectOptions, InitOptions, OnyxKey, OnyxMergeCollectionInput, OnyxMergeInput, OnyxMultiSetInput, OnyxSetInput, OnyxUpdate, SetOptions } from './types';
 import type { Connection } from './OnyxConnectionManager';
 /** Initialize the store with actions and listening for storage events */
-declare function init({ keys, initialKeyStates, evictableKeys, maxCachedKeysCount, shouldSyncMultipleInstances, debugSetState, enablePerformanceMetrics, skippableCollectionMemberIDs, }: InitOptions): void;
+declare function init({ keys, initialKeyStates, evictableKeys, maxCachedKeysCount, shouldSyncMultipleInstances, enablePerformanceMetrics, skippableCollectionMemberIDs, }: InitOptions): void;
 /**
  * Connects to an Onyx key given the options passed and listens to its changes.
  * This method will be deprecated soon. Please use `Onyx.connectWithoutView()` instead.
@@ -19,11 +19,8 @@ declare function init({ keys, initialKeyStates, evictableKeys, maxCachedKeysCoun
  * @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.withOnyxInstance The `withOnyx` class instance to be internally passed. **Only used inside `withOnyx()` HOC.**
- * @param connectOptions.statePropertyName The name of the component's prop that is connected to the Onyx key. **Only used inside `withOnyx()` HOC.**
- * @param connectOptions.displayName The component's display name. **Only used inside `withOnyx()` HOC.**
- * @param connectOptions.selector This will be used to subscribe to a subset of an Onyx key's data. **Only used inside `useOnyx()` hook or `withOnyx()` HOC.**
- *        Using this setting on `useOnyx()` or `withOnyx()` can have very positive performance benefits because the component will only re-render
+ * @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
  *        cause the component to re-render (and that can be expensive from a performance standpoint).
  * @returns The connection object to use when calling `Onyx.disconnect()`.
@@ -44,11 +41,8 @@ declare function connect<TKey extends OnyxKey>(connectOptions: ConnectOptions<TK
  * @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.withOnyxInstance The `withOnyx` class instance to be internally passed. **Only used inside `withOnyx()` HOC.**
- * @param connectOptions.statePropertyName The name of the component's prop that is connected to the Onyx key. **Only used inside `withOnyx()` HOC.**
- * @param connectOptions.displayName The component's display name. **Only used inside `withOnyx()` HOC.**
- * @param connectOptions.selector This will be used to subscribe to a subset of an Onyx key's data. **Only used inside `useOnyx()` hook or `withOnyx()` HOC.**
- *        Using this setting on `useOnyx()` or `withOnyx()` can have very positive performance benefits because the component will only re-render
+ * @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
  *        cause the component to re-render (and that can be expensive from a performance standpoint).
  * @returns The connection object to use when calling `Onyx.disconnect()`.
@@ -183,4 +177,4 @@ declare const Onyx: {
     registerLogger: typeof Logger.registerLogger;
 };
 export default Onyx;
-export type { OnyxUpdate, Mapping, ConnectOptions, SetOptions };
+export type { OnyxUpdate, ConnectOptions, SetOptions };

package/dist/Onyx.js

@@ -38,7 +38,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const Logger = __importStar(require("./Logger"));
 const OnyxCache_1 = __importStar(require("./OnyxCache"));
-const PerformanceUtils = __importStar(require("./PerformanceUtils"));
 const storage_1 = __importDefault(require("./storage"));
 const utils_1 = __importDefault(require("./utils"));
 const DevTools_1 = __importDefault(require("./DevTools"));
@@ -49,7 +48,7 @@ const GlobalSettings = __importStar(require("./GlobalSettings"));
 const metrics_1 = __importDefault(require("./metrics"));
 const OnyxMerge_1 = __importDefault(require("./OnyxMerge"));
 /** Initialize the store with actions and listening for storage events */
-function init({ keys = {}, initialKeyStates = {}, evictableKeys = [], maxCachedKeysCount = 1000, shouldSyncMultipleInstances = !!global.localStorage, debugSetState = false, enablePerformanceMetrics = false, skippableCollectionMemberIDs = [], }) {
+function init({ keys = {}, initialKeyStates = {}, evictableKeys = [], maxCachedKeysCount = 1000, shouldSyncMultipleInstances = !!global.localStorage, enablePerformanceMetrics = false, skippableCollectionMemberIDs = [], }) {
     var _a;
     if (enablePerformanceMetrics) {
         GlobalSettings.setPerformanceMetricsEnabled(true);
@@ -59,14 +58,10 @@ function init({ keys = {}, initialKeyStates = {}, evictableKeys = [], maxCachedK
     OnyxUtils_1.default.setSkippableCollectionMemberIDs(new Set(skippableCollectionMemberIDs));
     if (shouldSyncMultipleInstances) {
         (_a = storage_1.default.keepInstancesSync) === null || _a === void 0 ? void 0 : _a.call(storage_1.default, (key, value) => {
-            const prevValue = OnyxCache_1.default.get(key, false);
             OnyxCache_1.default.set(key, value);
-            OnyxUtils_1.default.keyChanged(key, value, prevValue);
+            OnyxUtils_1.default.keyChanged(key, value);
         });
     }
-    if (debugSetState) {
-        PerformanceUtils.setShouldDebugSetState(true);
-    }
     if (maxCachedKeysCount > 0) {
         OnyxCache_1.default.setRecentKeysLimit(maxCachedKeysCount);
     }
@@ -90,11 +85,8 @@ function init({ keys = {}, initialKeyStates = {}, evictableKeys = [], maxCachedK
  * @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.withOnyxInstance The `withOnyx` class instance to be internally passed. **Only used inside `withOnyx()` HOC.**
- * @param connectOptions.statePropertyName The name of the component's prop that is connected to the Onyx key. **Only used inside `withOnyx()` HOC.**
- * @param connectOptions.displayName The component's display name. **Only used inside `withOnyx()` HOC.**
- * @param connectOptions.selector This will be used to subscribe to a subset of an Onyx key's data. **Only used inside `useOnyx()` hook or `withOnyx()` HOC.**
- *        Using this setting on `useOnyx()` or `withOnyx()` can have very positive performance benefits because the component will only re-render
+ * @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
  *        cause the component to re-render (and that can be expensive from a performance standpoint).
  * @returns The connection object to use when calling `Onyx.disconnect()`.
@@ -117,11 +109,8 @@ function connect(connectOptions) {
  * @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.withOnyxInstance The `withOnyx` class instance to be internally passed. **Only used inside `withOnyx()` HOC.**
- * @param connectOptions.statePropertyName The name of the component's prop that is connected to the Onyx key. **Only used inside `withOnyx()` HOC.**
- * @param connectOptions.displayName The component's display name. **Only used inside `withOnyx()` HOC.**
- * @param connectOptions.selector This will be used to subscribe to a subset of an Onyx key's data. **Only used inside `useOnyx()` hook or `withOnyx()` HOC.**
- *        Using this setting on `useOnyx()` or `withOnyx()` can have very positive performance benefits because the component will only re-render
+ * @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
  *        cause the component to re-render (and that can be expensive from a performance standpoint).
  * @returns The connection object to use when calling `Onyx.disconnect()`.
@@ -240,7 +229,6 @@ function multiSet(data) {
     }
     const keyValuePairsToSet = OnyxUtils_1.default.prepareKeyValuePairsForStorage(newData, true);
     const updatePromises = keyValuePairsToSet.map(([key, value]) => {
-        const prevValue = OnyxCache_1.default.get(key, false);
         // When we use multiSet to set a key we want to clear the current delta changes from Onyx.merge that were queued
         // before the value was set. If Onyx.merge is currently reading the old value from storage, it will then not apply the changes.
         if (OnyxUtils_1.default.hasPendingMergeForKey(key)) {
@@ -248,7 +236,7 @@ function multiSet(data) {
         }
         // Update cache and optimistically inform subscribers on the next tick
         OnyxCache_1.default.set(key, value);
-        return OnyxUtils_1.default.scheduleSubscriberUpdate(key, value, prevValue);
+        return OnyxUtils_1.default.scheduleSubscriberUpdate(key, value);
     });
     return storage_1.default.multiSet(keyValuePairsToSet)
         .catch((error) => OnyxUtils_1.default.evictStorageAndRetry(error, multiSet, newData))
@@ -435,7 +423,7 @@ function clear(keysToPreserve = []) {
         const updatePromises = [];
         // Notify the subscribers for each key/value group so they can receive the new values
         Object.entries(keyValuesToResetIndividually).forEach(([key, value]) => {
-            updatePromises.push(OnyxUtils_1.default.scheduleSubscriberUpdate(key, value, OnyxCache_1.default.get(key, false)));
+            updatePromises.push(OnyxUtils_1.default.scheduleSubscriberUpdate(key, value));
         });
         Object.entries(keyValuesToResetAsCollection).forEach(([key, value]) => {
             updatePromises.push(OnyxUtils_1.default.scheduleNotifyCollectionSubscribers(key, value));

package/dist/OnyxConnectionManager.d.ts

@@ -14,7 +14,7 @@ type Connection = {
     callbackID: string;
 };
 /**
- * Manages Onyx connections of `Onyx.connect()`, `useOnyx()` and `withOnyx()` subscribers.
+ * Manages Onyx connections of `Onyx.connect()` and `useOnyx()` subscribers.
  */
 declare class OnyxConnectionManager {
     /**

package/dist/OnyxConnectionManager.js

@@ -40,11 +40,10 @@ const bindAll_1 = __importDefault(require("lodash/bindAll"));
 const Logger = __importStar(require("./Logger"));
 const OnyxUtils_1 = __importDefault(require("./OnyxUtils"));
 const Str = __importStar(require("./Str"));
-const utils_1 = __importDefault(require("./utils"));
 const OnyxCache_1 = __importDefault(require("./OnyxCache"));
 const OnyxSnapshotCache_1 = __importDefault(require("./OnyxSnapshotCache"));
 /**
- * Manages Onyx connections of `Onyx.connect()`, `useOnyx()` and `withOnyx()` subscribers.
+ * Manages Onyx connections of `Onyx.connect()` and `useOnyx()` subscribers.
  */
 class OnyxConnectionManager {
     constructor() {
@@ -70,11 +69,9 @@ class OnyxConnectionManager {
         // - `initWithStoredValues` is `false`. This flag changes the subscription flow when set to `false`, so the connection can't 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.
-        // - `withOnyxInstance` is defined inside `connectOptions`. That means the subscriber is a `withOnyx` HOC and therefore doesn't support connection reuse.
         if (reuseConnection === false ||
             initWithStoredValues === false ||
-            (!utils_1.default.hasWithOnyxInstance(connectOptions) && OnyxUtils_1.default.isCollectionKey(key) && (waitForCollectionCallback === undefined || waitForCollectionCallback === false)) ||
-            utils_1.default.hasWithOnyxInstance(connectOptions)) {
+            (OnyxUtils_1.default.isCollectionKey(key) && (waitForCollectionCallback === undefined || waitForCollectionCallback === false))) {
             suffix += `,uniqueID=${Str.guid()}`;
         }
         return `onyxKey=${key},initWithStoredValues=${initWithStoredValues !== null && initWithStoredValues !== void 0 ? initWithStoredValues : true},waitForCollectionCallback=${waitForCollectionCallback !== null && waitForCollectionCallback !== void 0 ? waitForCollectionCallback : false}${suffix}`;
@@ -106,23 +103,18 @@ class OnyxConnectionManager {
         const callbackID = String(this.lastCallbackID++);
         // If there is no connection yet for that connection ID, we create a new one.
         if (!connectionMetadata) {
-            let callback;
-            // If the subscriber is a `withOnyx` HOC we don't define `callback` as the HOC will use
-            // its own logic to handle the data.
-            if (!utils_1.default.hasWithOnyxInstance(connectOptions)) {
-                callback = (value, key, sourceValue) => {
-                    const createdConnection = this.connectionsMap.get(connectionID);
-                    if (createdConnection) {
-                        // We signal that the first connection was made and now any new subscribers
-                        // can fire their callbacks immediately with the cached value when connecting.
-                        createdConnection.isConnectionMade = true;
-                        createdConnection.cachedCallbackValue = value;
-                        createdConnection.cachedCallbackKey = key;
-                        createdConnection.sourceValue = sourceValue;
-                        this.fireCallbacks(connectionID);
-                    }
-                };
-            }
+            const callback = (value, key, sourceValue) => {
+                const createdConnection = this.connectionsMap.get(connectionID);
+                if (createdConnection) {
+                    // We signal that the first connection was made and now any new subscribers
+                    // can fire their callbacks immediately with the cached value when connecting.
+                    createdConnection.isConnectionMade = true;
+                    createdConnection.cachedCallbackValue = value;
+                    createdConnection.cachedCallbackKey = key;
+                    createdConnection.sourceValue = sourceValue;
+                    this.fireCallbacks(connectionID);
+                }
+            };
             subscriptionID = OnyxUtils_1.default.subscribeToKey(Object.assign(Object.assign({}, connectOptions), { callback: callback }));
             connectionMetadata = {
                 subscriptionID,

package/dist/OnyxUtils.d.ts

@@ -1,8 +1,7 @@
 import type { ValueOf } from 'type-fest';
 import type Onyx from './Onyx';
-import type { CollectionKey, CollectionKeyBase, ConnectOptions, DeepRecord, KeyValueMapping, Mapping, MultiMergeReplaceNullPatches, OnyxCollection, OnyxEntry, OnyxInput, OnyxKey, OnyxMergeCollectionInput, OnyxUpdate, OnyxValue, Selector } from './types';
+import type { CollectionKey, CollectionKeyBase, ConnectOptions, DeepRecord, KeyValueMapping, CallbackToStateMapping, MultiMergeReplaceNullPatches, OnyxCollection, OnyxEntry, OnyxInput, OnyxKey, OnyxMergeCollectionInput, OnyxUpdate, OnyxValue, Selector } from './types';
 import type { FastMergeResult } from './utils';
-import type { WithOnyxState } from './withOnyx/types';
 import type { DeferredTask } from './createDeferredTask';
 import type { StorageKeyValuePair } from './storage/providers/types';
 declare const METHOD: {
@@ -70,7 +69,7 @@ declare function batchUpdates(updates: () => void): Promise<void>;
  * and runs it through a reducer function to return a subset of the data according to a selector.
  * The resulting collection will only contain items that are returned by the selector.
  */
-declare function reduceCollectionWithSelector<TKey extends CollectionKeyBase, TMap, TReturn>(collection: OnyxCollection<KeyValueMapping[TKey]>, selector: Selector<TKey, TMap, TReturn>, withOnyxInstanceState: WithOnyxState<TMap> | undefined): Record<string, TReturn>;
+declare function reduceCollectionWithSelector<TKey extends CollectionKeyBase, TReturn>(collection: OnyxCollection<KeyValueMapping[TKey]>, selector: Selector<TKey, TReturn>): Record<string, TReturn>;
 /** 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>>>;
@@ -138,41 +137,39 @@ declare function getCollectionKey(key: CollectionKey): 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.
  */
-declare function tryGetCachedValue<TKey extends OnyxKey>(key: TKey, mapping?: Partial<Mapping<TKey>>): OnyxValue<OnyxKey>;
+declare function tryGetCachedValue<TKey extends OnyxKey>(key: TKey): OnyxValue<OnyxKey>;
 declare function getCachedCollection<TKey extends CollectionKeyBase>(collectionKey: TKey, collectionMemberKeys?: string[]): NonNullable<OnyxCollection<KeyValueMapping[TKey]>>;
 /**
  * When a collection of keys change, search for any callbacks matching the collection key and trigger those callbacks
  */
-declare function keysChanged<TKey extends CollectionKeyBase>(collectionKey: TKey, partialCollection: OnyxCollection<KeyValueMapping[TKey]>, partialPreviousCollection: OnyxCollection<KeyValueMapping[TKey]> | undefined, notifyConnectSubscribers?: boolean, notifyWithOnyxSubscribers?: boolean): void;
+declare function keysChanged<TKey extends CollectionKeyBase>(collectionKey: TKey, partialCollection: OnyxCollection<KeyValueMapping[TKey]>, partialPreviousCollection: OnyxCollection<KeyValueMapping[TKey]> | undefined, notifyConnectSubscribers?: boolean): void;
 /**
  * When a key change happens, search for any callbacks matching the key or collection key and trigger those callbacks
  *
  * @example
  * keyChanged(key, value, subscriber => subscriber.initWithStoredValues === false)
  */
-declare function keyChanged<TKey extends OnyxKey>(key: TKey, value: OnyxValue<TKey>, previousValue: OnyxValue<TKey>, canUpdateSubscriber?: (subscriber?: Mapping<OnyxKey>) => boolean, notifyConnectSubscribers?: boolean, notifyWithOnyxSubscribers?: boolean): void;
+declare function keyChanged<TKey extends OnyxKey>(key: TKey, value: OnyxValue<TKey>, canUpdateSubscriber?: (subscriber?: CallbackToStateMapping<OnyxKey>) => boolean, notifyConnectSubscribers?: boolean): void;
 /**
- * Sends the data obtained from the keys to the connection. It either:
- *     - sets state on the withOnyxInstances
- *     - triggers the callback function
+ * Sends the data obtained from the keys to the connection.
  */
-declare function sendDataToConnection<TKey extends OnyxKey>(mapping: Mapping<TKey>, value: OnyxValue<TKey> | null, matchedKey: TKey | undefined, isBatched: boolean): void;
+declare function sendDataToConnection<TKey extends OnyxKey>(mapping: CallbackToStateMapping<TKey>, value: OnyxValue<TKey> | null, matchedKey: TKey | undefined): void;
 /**
  * We check to see if this key is flagged as safe for eviction and add it to the recentlyAccessedKeys list so that when we
  * run out of storage the least recently accessed key can be removed.
  */
-declare function addKeyToRecentlyAccessedIfNeeded<TKey extends OnyxKey>(mapping: Mapping<TKey>): void;
+declare function addKeyToRecentlyAccessedIfNeeded<TKey extends OnyxKey>(key: TKey): void;
 /**
  * Gets the data for a given an array of matching keys, combines them into an object, and sends the result back to the subscriber.
  */
-declare function getCollectionDataAndSendAsObject<TKey extends OnyxKey>(matchingKeys: CollectionKeyBase[], mapping: Mapping<TKey>): void;
+declare function getCollectionDataAndSendAsObject<TKey extends OnyxKey>(matchingKeys: CollectionKeyBase[], mapping: CallbackToStateMapping<TKey>): void;
 /**
  * Schedules an update that will be appended to the macro task queue (so it doesn't update the subscribers immediately).
  *
  * @example
  * scheduleSubscriberUpdate(key, value, subscriber => subscriber.initWithStoredValues === false)
  */
-declare function scheduleSubscriberUpdate<TKey extends OnyxKey>(key: TKey, value: OnyxValue<TKey>, previousValue: OnyxValue<TKey>, canUpdateSubscriber?: (subscriber?: Mapping<OnyxKey>) => boolean): Promise<void>;
+declare function scheduleSubscriberUpdate<TKey extends OnyxKey>(key: TKey, value: OnyxValue<TKey>, canUpdateSubscriber?: (subscriber?: CallbackToStateMapping<OnyxKey>) => boolean): Promise<void>;
 /**
  * This method is similar to notifySubscribersOnNextTick but it is built for working specifically with collections
  * so that keysChanged() is triggered for the collection and not keyChanged(). If this was not done, then the