react-native-onyx 2.0.71 → 2.0.73

package/dist/useOnyx.d.ts

@@ -1,5 +1,4 @@
-import type { IsEqual } from 'type-fest';
-import type { CollectionKeyBase, OnyxCollection, OnyxEntry, OnyxKey, OnyxValue, Selector } from './types';
+import type { OnyxKey, OnyxValue } from './types';
 type BaseUseOnyxOptions = {
     /**
      * Determines if this key in this subscription is safe to be evicted.
@@ -20,23 +19,23 @@ type UseOnyxInitialValueOption<TInitialValue> = {
      */
     initialValue?: TInitialValue;
 };
+type UseOnyxSelector<TKey extends OnyxKey, TReturnValue = OnyxValue<TKey>> = (data: OnyxValue<TKey> | undefined) => TReturnValue;
 type UseOnyxSelectorOption<TKey extends OnyxKey, 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).
+     * @see `useOnyx` cannot return `null` and so selector will replace `null` with `undefined` to maintain compatibility.
      */
-    selector?: Selector<TKey, unknown, TReturnValue>;
+    selector?: UseOnyxSelector<TKey, TReturnValue>;
 };
 type FetchStatus = 'loading' | 'loaded';
-type SelectedValue<TKey, TValue> = TKey extends CollectionKeyBase ? OnyxCollection<TValue> : OnyxEntry<TValue>;
-type CachedValue<TKey extends OnyxKey, TValue> = IsEqual<TValue, OnyxValue<TKey>> extends true ? TValue : SelectedValue<TKey, 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?: BaseUseOnyxOptions & UseOnyxInitialValueOption<TReturnValue> & Required<UseOnyxSelectorOption<TKey, TReturnValue>>): UseOnyxResult<TKey, TReturnValue>;
-declare function useOnyx<TKey extends OnyxKey, TReturnValue = OnyxValue<TKey>>(key: TKey, options?: BaseUseOnyxOptions & UseOnyxInitialValueOption<NoInfer<TReturnValue>>): UseOnyxResult<TKey, TReturnValue>;
+type UseOnyxResult<TValue> = [NonNullable<TValue> | undefined, ResultMetadata];
+declare function useOnyx<TKey extends OnyxKey, TReturnValue = OnyxValue<TKey>>(key: TKey, options?: BaseUseOnyxOptions & UseOnyxInitialValueOption<TReturnValue> & Required<UseOnyxSelectorOption<TKey, TReturnValue>>): UseOnyxResult<TReturnValue>;
+declare function useOnyx<TKey extends OnyxKey, TReturnValue = OnyxValue<TKey>>(key: TKey, options?: BaseUseOnyxOptions & UseOnyxInitialValueOption<NoInfer<TReturnValue>>): UseOnyxResult<TReturnValue>;
 export default useOnyx;
 export type { FetchStatus, ResultMetadata, UseOnyxResult };

package/dist/useOnyx.js

@@ -10,9 +10,36 @@ const OnyxConnectionManager_1 = __importDefault(require("./OnyxConnectionManager
 const OnyxUtils_1 = __importDefault(require("./OnyxUtils"));
 const useLiveRef_1 = __importDefault(require("./useLiveRef"));
 const usePrevious_1 = __importDefault(require("./usePrevious"));
+/**
+ * Gets the cached value from the Onyx cache. If the key is a collection key, it will return all the values in the collection.
+ * It is a fork of `tryGetCachedValue` from `OnyxUtils` caused by different selector logic in `useOnyx`. It should be unified in the future, when `withOnyx` is removed.
+ */
+function tryGetCachedValue(key) {
+    if (!OnyxUtils_1.default.isCollectionKey(key)) {
+        return OnyxCache_1.default.get(key);
+    }
+    const allCacheKeys = OnyxCache_1.default.getAllKeys();
+    // It is possible we haven't loaded all keys yet so we do not know if the
+    // collection actually exists.
+    if (allCacheKeys.size === 0) {
+        return;
+    }
+    const values = {};
+    allCacheKeys.forEach((cacheKey) => {
+        if (!cacheKey.startsWith(key)) {
+            return;
+        }
+        values[cacheKey] = OnyxCache_1.default.get(cacheKey);
+    });
+    return values;
+}
+/**
+ * Gets the value from cache and maps it with selector. It changes `null` to `undefined` for `useOnyx` compatibility.
+ */
 function getCachedValue(key, selector) {
-    var _a;
-    return ((_a = OnyxUtils_1.default.tryGetCachedValue(key, { selector })) !== null && _a !== void 0 ? _a : undefined);
+    const value = tryGetCachedValue(key);
+    const selectedValue = selector ? selector(value) : value;
+    return selectedValue !== null && selectedValue !== void 0 ? selectedValue : undefined;
 }
 function useOnyx(key, options) {
     const connectionRef = (0, react_1.useRef)(null);
@@ -73,7 +100,7 @@ function useOnyx(key, options) {
         }
     }, [key, options === null || options === void 0 ? void 0 : options.canEvict]);
     const getSnapshot = (0, react_1.useCallback)(() => {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         // We return the initial result right away during the first connection if `initWithStoredValues` is set to `false`.
         if (isFirstConnectionRef.current && (options === null || options === void 0 ? void 0 : options.initWithStoredValues) === false) {
             return resultRef.current;
@@ -107,7 +134,7 @@ function useOnyx(key, options) {
             newValueRef.current = ((_a = options === null || options === void 0 ? void 0 : options.initialValue) !== null && _a !== void 0 ? _a : undefined);
             newFetchStatus = 'loaded';
         }
-        // We do a deep equality check if `selector` is defined, since each `OnyxUtils.tryGetCachedValue()` call will
+        // We do a deep equality check if `selector` is defined, since each `tryGetCachedValue()` call will
         // generate a plain new primitive/object/array that was created using the `selector` function.
         // For the other cases we will only deal with object reference checks, so just a shallow equality check is enough.
         let areValuesEqual;
@@ -124,10 +151,10 @@ function useOnyx(key, options) {
         if (isCacheSetFirstTime || !areValuesEqual) {
             previousValueRef.current = newValueRef.current;
             // If the new value is `null` we default it to `undefined` to ensure the consumer gets a consistent result from the hook.
-            resultRef.current = [previousValueRef.current, { status: newFetchStatus !== null && newFetchStatus !== void 0 ? newFetchStatus : 'loaded' }];
+            resultRef.current = [(_d = previousValueRef.current) !== null && _d !== void 0 ? _d : undefined, { status: newFetchStatus !== null && newFetchStatus !== void 0 ? newFetchStatus : 'loaded' }];
         }
         return resultRef.current;
-    }, [key, selectorRef, options === null || options === void 0 ? void 0 : options.initWithStoredValues, options === null || options === void 0 ? void 0 : options.allowStaleData, options === null || options === void 0 ? void 0 : options.initialValue]);
+    }, [options === null || options === void 0 ? void 0 : options.initWithStoredValues, options === null || options === void 0 ? void 0 : options.allowStaleData, options === null || options === void 0 ? void 0 : options.initialValue, key, selectorRef]);
     const subscribe = (0, react_1.useCallback)((onStoreChange) => {
         connectionRef.current = OnyxConnectionManager_1.default.connect({
             key,

package/package.json

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