react-native-onyx 2.0.17 → 2.0.18

package/API.md

@@ -22,8 +22,15 @@ cause react to schedule the updates at once instead of after each other. This is
 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.</p>
 </dd>
+<dt><a href="#isCollectionKey">isCollectionKey(key)</a> ⇒ <code>Boolean</code></dt>
+<dd><p>Checks to see if the a subscriber&#39;s supplied key
+is associated with a collection of keys.</p>
+</dd>
 <dt><a href="#isCollectionMemberKey">isCollectionMemberKey(collectionKey, key)</a> ⇒ <code>Boolean</code></dt>
 <dd></dd>
+<dt><a href="#splitCollectionMemberKey">splitCollectionMemberKey(key)</a> ⇒ <code>Array.&lt;String&gt;</code></dt>
+<dd><p>Splits a collection member key into the collection key part and the ID part.</p>
+</dd>
 <dt><a href="#tryGetCachedValue">tryGetCachedValue(key, mapping)</a> ⇒ <code>Mixed</code></dt>
 <dd><p>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.</p>
@@ -34,7 +41,7 @@ If the requested key is a collection, it will return an object with all the coll
 <dt><a href="#disconnect">disconnect(connectionID, [keyToRemoveFromEvictionBlocklist])</a></dt>
 <dd><p>Remove the listener for a react component</p>
 </dd>
-<dt><a href="#scheduleSubscriberUpdate">scheduleSubscriberUpdate(key, value, [canUpdateSubscriber])</a> ⇒ <code>Promise</code></dt>
+<dt><a href="#scheduleSubscriberUpdate">scheduleSubscriberUpdate(key, value, prevValue, [canUpdateSubscriber])</a> ⇒ <code>Promise</code></dt>
 <dd><p>Schedules an update that will be appended to the macro task queue (so it doesn&#39;t update the subscribers immediately).</p>
 </dd>
 <dt><a href="#scheduleNotifyCollectionSubscribers">scheduleNotifyCollectionSubscribers(key, value)</a> ⇒ <code>Promise</code></dt>
@@ -90,13 +97,6 @@ value will be saved to storage after the default value.</p>
 <dt><a href="#setMemoryOnlyKeys">setMemoryOnlyKeys(keyList)</a></dt>
 <dd><p>When set these keys will not be persisted to storage</p>
 </dd>
-<dt><a href="#onClear">onClear(callback)</a></dt>
-<dd><p>Sets the callback to be called when the clear finishes executing.</p>
-</dd>
-<dt><a href="#subscribeToEvents">subscribeToEvents()</a></dt>
-<dd><p>Subscribes to the Broadcast channel and executes actions based on the
-types of events.</p>
-</dd>
 <dt><a href="#init">init([options])</a></dt>
 <dd><p>Initialize the store with actions and listening for storage events</p>
 </dd>
@@ -153,6 +153,18 @@ The resulting collection will only contain items that are returned by the select
 | selector | <code>String</code> \| <code>function</code> | (see method docs for getSubsetOfData() for full details) |
 | [withOnyxInstanceState] | <code>Object</code> |  |
 
+<a name="isCollectionKey"></a>
+
+## isCollectionKey(key) ⇒ <code>Boolean</code>
+Checks to see if the a subscriber's supplied key
+is associated with a collection of keys.
+
+**Kind**: global function  
+
+| Param | Type |
+| --- | --- |
+| key | <code>String</code> | 
+
 <a name="isCollectionMemberKey"></a>
 
 ## isCollectionMemberKey(collectionKey, key) ⇒ <code>Boolean</code>
@@ -163,6 +175,18 @@ The resulting collection will only contain items that are returned by the select
 | collectionKey | <code>String</code> | 
 | key | <code>String</code> | 
 
+<a name="splitCollectionMemberKey"></a>
+
+## splitCollectionMemberKey(key) ⇒ <code>Array.&lt;String&gt;</code>
+Splits a collection member key into the collection key part and the ID part.
+
+**Kind**: global function  
+**Returns**: <code>Array.&lt;String&gt;</code> - A tuple where the first element is the collection part and the second element is the ID part.  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| key | <code>String</code> | The collection member key to split. |
+
 <a name="tryGetCachedValue"></a>
 
 ## tryGetCachedValue(key, mapping) ⇒ <code>Mixed</code>
@@ -221,7 +245,7 @@ Onyx.disconnect(connectionID);
 ```
 <a name="scheduleSubscriberUpdate"></a>
 
-## scheduleSubscriberUpdate(key, value, [canUpdateSubscriber]) ⇒ <code>Promise</code>
+## scheduleSubscriberUpdate(key, value, prevValue, [canUpdateSubscriber]) ⇒ <code>Promise</code>
 Schedules an update that will be appended to the macro task queue (so it doesn't update the subscribers immediately).
 
 **Kind**: global function  
@@ -230,6 +254,7 @@ Schedules an update that will be appended to the macro task queue (so it doesn't
 | --- | --- | --- |
 | key | <code>String</code> |  |
 | value | <code>\*</code> |  |
+| prevValue | <code>\*</code> |  |
 | [canUpdateSubscriber] | <code>function</code> | only subscribers that pass this truth test will be updated |
 
 **Example**  
@@ -410,24 +435,6 @@ When set these keys will not be persisted to storage
 | --- | --- |
 | keyList | <code>Array.&lt;string&gt;</code> | 
 
-<a name="onClear"></a>
-
-## onClear(callback)
-Sets the callback to be called when the clear finishes executing.
-
-**Kind**: global function  
-
-| Param | Type |
-| --- | --- |
-| callback | <code>function</code> | 
-
-<a name="subscribeToEvents"></a>
-
-## subscribeToEvents()
-Subscribes to the Broadcast channel and executes actions based on the
-types of events.
-
-**Kind**: global function  
 <a name="init"></a>
 
 ## init([options])

package/dist/Onyx.d.ts

@@ -1,6 +1,6 @@
 import {Component} from 'react';
 import * as Logger from './Logger';
-import {CollectionKey, CollectionKeyBase, DeepRecord, KeyValueMapping, NullishDeep, OnyxCollection, OnyxEntry, OnyxKey} from './types';
+import {CollectionKey, CollectionKeyBase, DeepRecord, KeyValueMapping, NullishDeep, OnyxCollection, OnyxEntry, OnyxKey, Selector} from './types';
 
 /**
  * Represents a mapping object where each `OnyxKey` maps to either a value of its corresponding type in `KeyValueMapping` or `null`.
@@ -20,6 +20,11 @@ type BaseConnectOptions = {
     initWithStoredValues?: boolean;
 };
 
+type TryGetCachedValueMapping<TKey extends OnyxKey> = {
+    selector?: Selector<TKey, unknown, unknown>;
+    withOnyxInstance?: Component;
+};
+
 /**
  * Represents the options used in `Onyx.connect()` method.
  * The type is built from `BaseConnectOptions` and extended to handle key/callback related options.
@@ -35,7 +40,7 @@ type BaseConnectOptions = {
 type ConnectOptions<TKey extends OnyxKey> = BaseConnectOptions &
     (
         | {
-              key: TKey extends CollectionKey ? TKey : never;
+              key: TKey extends CollectionKeyBase ? TKey : never;
               callback?: (value: OnyxCollection<KeyValueMapping[TKey]>) => void;
               waitForCollectionCallback: true;
           }
@@ -114,6 +119,21 @@ declare const METHOD: {
  */
 declare function getAllKeys(): Promise<Array<OnyxKey>>;
 
+/**
+ * Checks to see if the a subscriber's supplied key
+ * is associated with a collection of keys.
+ */
+declare function isCollectionKey(key: OnyxKey): key is CollectionKeyBase;
+
+declare function isCollectionMemberKey<TCollectionKey extends CollectionKeyBase>(collectionKey: TCollectionKey, key: string): key is `${TCollectionKey}${string}`;
+
+/**
+ * Splits a collection member key into the collection key part and the ID part.
+ * @param key - The collection member key to split.
+ * @returns A tuple where the first element is the collection part and the second element is the ID part.
+ */
+declare function splitCollectionMemberKey<TKey extends CollectionKey>(key: TKey): [TKey extends `${infer Prefix}_${string}` ? `${Prefix}_` : never, string];
+
 /**
  * Checks to see if this key has been flagged as
  * safe for removal.
@@ -289,6 +309,15 @@ declare function hasPendingMergeForKey(key: OnyxKey): boolean;
  */
 declare function setMemoryOnlyKeys(keyList: OnyxKey[]): void;
 
+/**
+ * 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?: TryGetCachedValueMapping,
+): TKey extends CollectionKeyBase ? OnyxCollection<KeyValueMapping[TKey]> | undefined : OnyxEntry<KeyValueMapping[TKey]> | undefined;
+
 declare const Onyx: {
     connect: typeof connect;
     disconnect: typeof disconnect;
@@ -307,7 +336,11 @@ declare const Onyx: {
     isSafeEvictionKey: typeof isSafeEvictionKey;
     METHOD: typeof METHOD;
     setMemoryOnlyKeys: typeof setMemoryOnlyKeys;
+    tryGetCachedValue: typeof tryGetCachedValue;
+    isCollectionKey: typeof isCollectionKey;
+    isCollectionMemberKey: typeof isCollectionMemberKey;
+    splitCollectionMemberKey: typeof splitCollectionMemberKey;
 };
 
 export default Onyx;
-export {OnyxUpdate, ConnectOptions};
+export {ConnectOptions, OnyxUpdate};

package/dist/Onyx.js

@@ -189,7 +189,6 @@ function getAllKeys() {
  * Checks to see if the a subscriber's supplied key
  * is associated with a collection of keys.
  *
- * @private
  * @param {String} key
  * @returns {Boolean}
  */
@@ -204,6 +203,18 @@ function isCollectionKey(key) {
 function isCollectionMemberKey(collectionKey, key) {
     return Str.startsWith(key, collectionKey) && key.length > collectionKey.length;
 }
+/**
+ * Splits a collection member key into the collection key part and the ID part.
+ * @param {String} key - The collection member key to split.
+ * @returns {Array<String>} 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('_');
+    if (underscoreIndex === -1) {
+        throw new Error(`Invalid ${key} key provided, only collection keys are allowed.`);
+    }
+    return [key.substring(0, underscoreIndex + 1), key.substring(underscoreIndex + 1)];
+}
 /**
  * Checks to see if a provided key is the exact configured key of our connected subscriber
  * or if the provided key is a collection member key (in case our configured key is a "collection key")
@@ -1483,5 +1494,8 @@ const Onyx = {
     setMemoryOnlyKeys,
     tryGetCachedValue,
     hasPendingMergeForKey,
+    isCollectionKey,
+    isCollectionMemberKey,
+    splitCollectionMemberKey,
 };
 exports.default = Onyx;

package/dist/index.d.ts

@@ -1,6 +1,23 @@
 import Onyx, {OnyxUpdate, ConnectOptions} from './Onyx';
-import {CustomTypeOptions, OnyxCollection, OnyxEntry, NullishDeep, KeyValueMapping, OnyxKey, Selector, WithOnyxInstanceState} from './types';
+import {CustomTypeOptions, OnyxCollection, OnyxEntry, NullishDeep, KeyValueMapping, OnyxKey, Selector, WithOnyxInstanceState, OnyxValue} from './types';
 import withOnyx from './withOnyx';
+import useOnyx, {UseOnyxResult, FetchStatus} from './useOnyx';
 
 export default Onyx;
-export {CustomTypeOptions, OnyxCollection, OnyxEntry, OnyxUpdate, withOnyx, ConnectOptions, NullishDeep, KeyValueMapping, OnyxKey, Selector, WithOnyxInstanceState};
+export {
+    CustomTypeOptions,
+    OnyxCollection,
+    OnyxEntry,
+    OnyxUpdate,
+    withOnyx,
+    ConnectOptions,
+    NullishDeep,
+    KeyValueMapping,
+    OnyxKey,
+    Selector,
+    WithOnyxInstanceState,
+    useOnyx,
+    UseOnyxResult,
+    OnyxValue,
+    FetchStatus,
+};

package/dist/index.js

@@ -3,8 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.withOnyx = void 0;
+exports.useOnyx = exports.withOnyx = void 0;
 const Onyx_1 = __importDefault(require("./Onyx"));
 const withOnyx_1 = __importDefault(require("./withOnyx"));
 exports.withOnyx = withOnyx_1.default;
+const useOnyx_1 = __importDefault(require("./useOnyx"));
+exports.useOnyx = useOnyx_1.default;
 exports.default = Onyx_1.default;

package/dist/storage/__mocks__/index.js

@@ -15,13 +15,17 @@ const idbKeyvalMock = {
     },
     multiSet(pairs) {
         const setPromises = pairs.map(([key, value]) => this.setItem(key, value));
-        return new Promise((resolve) => Promise.all(setPromises).then(() => resolve(storageMapInternal)));
+        return new Promise((resolve) => {
+            Promise.all(setPromises).then(() => resolve(storageMapInternal));
+        });
     },
     getItem(key) {
         return Promise.resolve(storageMapInternal[key]);
     },
     multiGet(keys) {
-        const getPromises = keys.map((key) => new Promise((resolve) => this.getItem(key).then((value) => resolve([key, value]))));
+        const getPromises = keys.map((key) => new Promise((resolve) => {
+            this.getItem(key).then((value) => resolve([key, value]));
+        }));
         return Promise.all(getPromises);
     },
     multiMerge(pairs) {

package/dist/types.d.ts

@@ -99,6 +99,11 @@ type CollectionKey = `${CollectionKeyBase}${string}`;
  */
 type OnyxKey = Key | CollectionKey;
 
+/**
+ * Represents a Onyx value that can be either a single entry or a collection of entries, depending on the `TKey` provided.
+ */
+type OnyxValue<TKey extends OnyxKey> = TKey extends CollectionKeyBase ? OnyxCollection<KeyValueMapping[TKey]> : OnyxEntry<KeyValueMapping[TKey]>;
+
 /**
  * Represents a mapping of Onyx keys to values, where keys are either normal or collection Onyx keys
  * and values are the corresponding values in Onyx's state.
@@ -239,6 +244,7 @@ export {
     OnyxCollection,
     OnyxEntry,
     OnyxKey,
+    OnyxValue,
     Selector,
     NullishDeep,
     WithOnyxInstanceState,

package/dist/useLiveRef.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+/**
+ * Creates a mutable reference to a value, useful when you need to
+ * maintain a reference to a value that may change over time without triggering re-renders.
+ */
+declare function useLiveRef<T>(value: T): import("react").MutableRefObject<T>;
+export default useLiveRef;

package/dist/useLiveRef.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+/**
+ * Creates a mutable reference to a value, useful when you need to
+ * maintain a reference to a value that may change over time without triggering re-renders.
+ */
+function useLiveRef(value) {
+    const ref = (0, react_1.useRef)(value);
+    ref.current = value;
+    return ref;
+}
+exports.default = useLiveRef;

package/dist/useOnyx.d.ts

@@ -0,0 +1,36 @@
+import type { IsEqual } from 'type-fest';
+import type { CollectionKeyBase, OnyxCollection, OnyxKey, OnyxValue, Selector } from './types';
+type UseOnyxOptions<TKey extends OnyxKey, TReturnValue> = {
+    /**
+     * Determines if this key in this subscription is safe to be evicted.
+     */
+    canEvict?: boolean;
+    /**
+     * If set to false, then no data will be prefilled into the component.
+     */
+    initWithStoredValues?: boolean;
+    /**
+     * If set to true, data will be retrieved from cache during the first render even if there is a pending merge for the key.
+     */
+    allowStaleData?: boolean;
+    /**
+     * This value will be returned by the hook on the first render while the data is being read from Onyx.
+     */
+    initialValue?: TReturnValue;
+    /**
+     * This will be used to subscribe to a subset of an Onyx key's data.
+     * 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).
+     */
+    selector?: Selector<TKey, unknown, TReturnValue>;
+};
+type FetchStatus = 'loading' | 'loaded';
+type CachedValue<TKey extends OnyxKey, TValue> = IsEqual<TValue, OnyxValue<TKey>> extends true ? TValue : TKey extends CollectionKeyBase ? NonNullable<OnyxCollection<TValue>> : TValue;
+type ResultMetadata = {
+    status: FetchStatus;
+};
+type UseOnyxResult<TKey extends OnyxKey, TValue> = [CachedValue<TKey, TValue>, ResultMetadata];
+declare function useOnyx<TKey extends OnyxKey, TReturnValue = OnyxValue<TKey>>(key: TKey, options?: UseOnyxOptions<TKey, TReturnValue>): UseOnyxResult<TKey, TReturnValue>;
+export default useOnyx;
+export type { UseOnyxResult, FetchStatus };

package/dist/useOnyx.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fast_equals_1 = require("fast-equals");
+const react_1 = require("react");
+const Onyx_1 = __importDefault(require("./Onyx"));
+const useLiveRef_1 = __importDefault(require("./useLiveRef"));
+const usePrevious_1 = __importDefault(require("./usePrevious"));
+function getCachedValue(key, selector) {
+    return Onyx_1.default.tryGetCachedValue(key, { selector });
+}
+function useOnyx(key, options) {
+    const connectionIDRef = (0, react_1.useRef)(null);
+    const previousKey = (0, usePrevious_1.default)(key);
+    // Used to stabilize the selector reference and avoid unnecessary calls to `getSnapshot()`.
+    const selectorRef = (0, useLiveRef_1.default)(options === null || options === void 0 ? void 0 : options.selector);
+    // Stores the previous cached value as it's necessary to compare with the new value in `getSnapshot()`.
+    // We initialize it to `undefined` to simulate that we don't have any value from cache yet.
+    const cachedValueRef = (0, react_1.useRef)(undefined);
+    // Stores the previously result returned by the hook, containing the data from cache and the fetch status.
+    // We initialize it to `null` and `loading` fetch status to simulate the initial result when the hook is loading from the cache.
+    // However, if `initWithStoredValues` is `true` we set the fetch status to `loaded` since we want to signal that data is ready.
+    const resultRef = (0, react_1.useRef)([
+        null,
+        {
+            status: (options === null || options === void 0 ? void 0 : options.initWithStoredValues) === false ? 'loaded' : 'loading',
+        },
+    ]);
+    // Indicates if it's the first Onyx connection of this hook or not, as we don't want certain use cases
+    // in `getSnapshot()` to be satisfied several times.
+    const isFirstConnectionRef = (0, react_1.useRef)(true);
+    (0, react_1.useEffect)(() => {
+        // These conditions will ensure we can only handle dynamic collection member keys from the same collection.
+        if (previousKey === key) {
+            return;
+        }
+        try {
+            const previousCollectionKey = Onyx_1.default.splitCollectionMemberKey(previousKey)[0];
+            const collectionKey = Onyx_1.default.splitCollectionMemberKey(key)[0];
+            if (Onyx_1.default.isCollectionMemberKey(previousCollectionKey, previousKey) && Onyx_1.default.isCollectionMemberKey(collectionKey, key) && previousCollectionKey === collectionKey) {
+                return;
+            }
+        }
+        catch (e) {
+            throw new Error(`'${previousKey}' key can't be changed to '${key}'. useOnyx() only supports dynamic keys if they are both collection member keys from the same collection e.g. from 'collection_id1' to 'collection_id2'.`);
+        }
+        throw new Error(`'${previousKey}' key can't be changed to '${key}'. useOnyx() only supports dynamic keys if they are both collection member keys from the same collection e.g. from 'collection_id1' to 'collection_id2'.`);
+    }, [previousKey, key]);
+    const getSnapshot = (0, react_1.useCallback)(() => {
+        var _a;
+        // We get the value from the cache, supplying a selector too in case it's defined.
+        // If `newValue` is `undefined` it means that the cache doesn't have a value for that key yet.
+        // If `newValue` is `null` or any other value if means that the cache does have a value for that key.
+        // This difference between `undefined` and other values is crucial and it's used to address the following
+        // conditions and use cases.
+        let newValue = getCachedValue(key, selectorRef.current);
+        // Since the fetch status can be different given the use cases below, we define the variable right away.
+        let newFetchStatus;
+        // If we have pending merge operations for the key during the first connection, we set the new value to `undefined`
+        // and fetch status to `loading` to simulate that it is still being loaded until we have the most updated data.
+        // If `allowStaleData` is `true` this logic will be ignored and cached value will be used, even if it's stale data.
+        if (isFirstConnectionRef.current && Onyx_1.default.hasPendingMergeForKey(key) && !(options === null || options === void 0 ? void 0 : options.allowStaleData)) {
+            newValue = undefined;
+            newFetchStatus = 'loading';
+        }
+        // If data is not present in cache (if it's `undefined`) and `initialValue` is set during the first connection,
+        // we set the new value to `initialValue` and fetch status to `loaded` since we already have some data to return to the consumer.
+        if (isFirstConnectionRef.current && newValue === undefined && (options === null || options === void 0 ? void 0 : options.initialValue) !== undefined) {
+            newValue = options === null || options === void 0 ? void 0 : options.initialValue;
+            newFetchStatus = 'loaded';
+        }
+        // If the previously cached value is different from the new value, we update both cached value
+        // and the result to be returned by the hook.
+        if (!(0, fast_equals_1.deepEqual)(cachedValueRef.current, newValue)) {
+            cachedValueRef.current = newValue;
+            // If the new value is `undefined` we default it to `null` to ensure the consumer get a consistent result from the hook.
+            resultRef.current = [((_a = cachedValueRef.current) !== null && _a !== void 0 ? _a : null), { status: newFetchStatus !== null && newFetchStatus !== void 0 ? newFetchStatus : 'loaded' }];
+        }
+        return resultRef.current;
+    }, [key, selectorRef, options === null || options === void 0 ? void 0 : options.allowStaleData, options === null || options === void 0 ? void 0 : options.initialValue]);
+    const subscribe = (0, react_1.useCallback)((onStoreChange) => {
+        connectionIDRef.current = Onyx_1.default.connect({
+            key: key,
+            callback: () => {
+                // We don't need to update the Onyx cache again here, when `callback` is called the cache is already
+                // expected to be updated, so we just signal that the store changed and `getSnapshot()` can be called again.
+                isFirstConnectionRef.current = false;
+                onStoreChange();
+            },
+            initWithStoredValues: options === null || options === void 0 ? void 0 : options.initWithStoredValues,
+            waitForCollectionCallback: Onyx_1.default.isCollectionKey(key),
+        });
+        return () => {
+            if (!connectionIDRef.current) {
+                return;
+            }
+            Onyx_1.default.disconnect(connectionIDRef.current);
+            isFirstConnectionRef.current = false;
+        };
+    }, [key, options === null || options === void 0 ? void 0 : options.initWithStoredValues]);
+    // Mimics withOnyx's checkEvictableKeys() behavior.
+    (0, react_1.useEffect)(() => {
+        if ((options === null || options === void 0 ? void 0 : options.canEvict) === undefined || !connectionIDRef.current) {
+            return;
+        }
+        if (!Onyx_1.default.isSafeEvictionKey(key)) {
+            throw new Error(`canEvict can't be used on key '${key}'. This key must explicitly be flagged as safe for removal by adding it to Onyx.init({safeEvictionKeys: []}).`);
+        }
+        if (options.canEvict) {
+            Onyx_1.default.removeFromEvictionBlockList(key, connectionIDRef.current);
+        }
+        else {
+            Onyx_1.default.addToEvictionBlockList(key, connectionIDRef.current);
+        }
+    }, [key, options === null || options === void 0 ? void 0 : options.canEvict]);
+    const result = (0, react_1.useSyncExternalStore)(subscribe, getSnapshot);
+    return result;
+}
+exports.default = useOnyx;

package/dist/usePrevious.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns the previous value of the provided value.
+ */
+declare function usePrevious<T>(value: T): T;
+export default usePrevious;

package/dist/usePrevious.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+/**
+ * Returns the previous value of the provided value.
+ */
+function usePrevious(value) {
+    const ref = (0, react_1.useRef)(value);
+    (0, react_1.useEffect)(() => {
+        ref.current = value;
+    }, [value]);
+    return ref.current;
+}
+exports.default = usePrevious;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-onyx",
-  "version": "2.0.17",
+  "version": "2.0.18",
   "author": "Expensify, Inc.",
   "homepage": "https://expensify.com",
   "description": "State management for React Native",
@@ -32,7 +32,7 @@
     "typecheck": "tsc --noEmit",
     "test": "jest",
     "build": "tsc -p tsconfig.build.json && cp ./lib/*.d.ts ./dist",
-    "build:watch": "nodemon --watch lib --exec \"npm run build && npm pack\"",
+    "build:watch": "nodemon --watch lib --ext js,json,ts,tsx --exec \"npm run build && npm pack\"",
     "build:docs": "node buildDocs.js",
     "lint-tests": "eslint tests/**",
     "prettier": "prettier --write ."
@@ -47,7 +47,7 @@
     "@react-native-community/eslint-config": "^3.2.0",
     "@react-native/polyfills": "^2.0.0",
     "@testing-library/jest-native": "^3.4.2",
-    "@testing-library/react-native": "^7.0.2",
+    "@testing-library/react-native": "^10.0.0",
     "@types/jest": "^28.1.8",
     "@types/lodash": "^4.14.202",
     "@types/node": "^20.11.5",
@@ -58,7 +58,7 @@
     "@typescript-eslint/eslint-plugin": "^6.19.0",
     "@typescript-eslint/parser": "^6.19.0",
     "eslint": "^8.56.0",
-    "eslint-config-expensify": "^2.0.43",
+    "eslint-config-expensify": "^2.0.44",
     "eslint-config-prettier": "^8.8.0",
     "eslint-plugin-import": "^2.29.1",
     "eslint-plugin-jsx-a11y": "^6.8.0",