react-native-onyx 2.0.47 → 2.0.48

package/dist/Onyx.js

@@ -501,7 +501,7 @@ function clear(keysToPreserve = []) {
             //      since collection key subscribers need to be updated differently
             if (!isKeyToPreserve) {
                 const oldValue = OnyxCache_1.default.get(key);
-                const newValue = (_a = defaultKeyStates[key]) !== null && _a !== void 0 ? _a : undefined;
+                const newValue = (_a = defaultKeyStates[key]) !== null && _a !== void 0 ? _a : null;
                 if (newValue !== oldValue) {
                     OnyxCache_1.default.set(key, newValue);
                     const collectionKey = key.substring(0, key.indexOf('_') + 1);
@@ -509,10 +509,10 @@ function clear(keysToPreserve = []) {
                         if (!keyValuesToResetAsCollection[collectionKey]) {
                             keyValuesToResetAsCollection[collectionKey] = {};
                         }
-                        keyValuesToResetAsCollection[collectionKey][key] = newValue;
+                        keyValuesToResetAsCollection[collectionKey][key] = newValue !== null && newValue !== void 0 ? newValue : undefined;
                     }
                     else {
-                        keyValuesToResetIndividually[key] = newValue;
+                        keyValuesToResetIndividually[key] = newValue !== null && newValue !== void 0 ? newValue : undefined;
                     }
                 }
             }

package/dist/useOnyx.js

@@ -9,8 +9,10 @@ const OnyxUtils_1 = __importDefault(require("./OnyxUtils"));
 const useLiveRef_1 = __importDefault(require("./useLiveRef"));
 const usePrevious_1 = __importDefault(require("./usePrevious"));
 const Onyx_1 = __importDefault(require("./Onyx"));
+const OnyxCache_1 = __importDefault(require("./OnyxCache"));
 function getCachedValue(key, selector) {
-    return OnyxUtils_1.default.tryGetCachedValue(key, { selector });
+    var _a;
+    return ((_a = OnyxUtils_1.default.tryGetCachedValue(key, { selector })) !== null && _a !== void 0 ? _a : undefined);
 }
 function useOnyx(key, options) {
     const connectionIDRef = (0, react_1.useRef)(null);
@@ -18,8 +20,8 @@ function useOnyx(key, options) {
     // 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);
+    // We initialize it to `null` to simulate that we don't have any value from cache yet.
+    const cachedValueRef = (0, react_1.useRef)(null);
     // Stores the previously result returned by the hook, containing the data from cache and the fetch status.
     // We initialize it to `undefined` 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.
@@ -50,13 +52,14 @@ function useOnyx(key, options) {
         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;
+        var _a, _b;
         // 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.
+        // If `newValue` is `null` or any other value it 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);
+        const hasCacheForKey = OnyxCache_1.default.hasCacheForKey(key);
         // 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`
@@ -66,18 +69,19 @@ function useOnyx(key, options) {
             newValue = undefined;
             newFetchStatus = 'loading';
         }
-        // If data is not present in cache (if it's `undefined`) and `initialValue` is set during the first connection,
+        // If data is not present in cache 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;
+        if (isFirstConnectionRef.current && !hasCacheForKey && (options === null || options === void 0 ? void 0 : options.initialValue) !== undefined) {
+            newValue = ((_a = options === null || options === void 0 ? void 0 : options.initialValue) !== null && _a !== void 0 ? _a : undefined);
             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)) {
+        // If the cache was set for the first time, we also update the cached value and the result.
+        const isCacheSetFirstTime = cachedValueRef.current === null && hasCacheForKey;
+        if (isCacheSetFirstTime || !(0, fast_equals_1.deepEqual)((_b = cachedValueRef.current) !== null && _b !== void 0 ? _b : undefined, newValue)) {
             cachedValueRef.current = newValue;
-            // If the new value is `null` we default it to `undefined` to ensure the consumer get a consistent result from the hook.
-            resultRef.current = [((_a = cachedValueRef.current) !== null && _a !== void 0 ? _a : undefined), { status: newFetchStatus !== null && newFetchStatus !== void 0 ? newFetchStatus : 'loaded' }];
+            resultRef.current = [cachedValueRef.current, { 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]);

package/package.json

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