react-native-onyx 2.0.47 → 2.0.49

package/dist/Onyx.js

@@ -28,6 +28,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 /* eslint-disable no-continue */
 const underscore_1 = __importDefault(require("underscore"));
+const pick_1 = __importDefault(require("lodash/pick"));
 const Logger = __importStar(require("./Logger"));
 const OnyxCache_1 = __importDefault(require("./OnyxCache"));
 const createDeferredTask_1 = __importDefault(require("./createDeferredTask"));
@@ -501,7 +502,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 +510,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;
                     }
                 }
             }
@@ -549,6 +550,36 @@ function clear(keysToPreserve = []) {
     })
         .then(() => undefined);
 }
+function updateSnapshots(data) {
+    const snapshotCollectionKey = OnyxUtils_1.default.getSnapshotKey();
+    if (!snapshotCollectionKey)
+        return;
+    const promises = [];
+    const snapshotCollection = OnyxUtils_1.default.getCachedCollection(snapshotCollectionKey);
+    Object.entries(snapshotCollection).forEach(([snapshotKey, snapshotValue]) => {
+        // Snapshots may not be present in cache. We don't know how to update them so we skip.
+        if (!snapshotValue) {
+            return;
+        }
+        let updatedData = {};
+        data.forEach(({ key, value }) => {
+            // snapshots are normal keys so we want to skip update if they are written to Onyx
+            if (OnyxUtils_1.default.isCollectionMemberKey(snapshotCollectionKey, key)) {
+                return;
+            }
+            if (typeof snapshotValue !== 'object' || !('data' in snapshotValue)) {
+                return;
+            }
+            const snapshotData = snapshotValue.data;
+            if (!snapshotData || !snapshotData[key]) {
+                return;
+            }
+            updatedData = Object.assign(Object.assign({}, updatedData), { [key]: (0, pick_1.default)(value, Object.keys(snapshotData[key])) });
+        });
+        promises.push(() => merge(snapshotKey, { data: updatedData }));
+    });
+    return Promise.all(promises.map((p) => p()));
+}
 /**
  * Insert API responses and lifecycle data into Onyx
  *
@@ -595,7 +626,10 @@ function update(data) {
                 break;
         }
     });
-    return clearPromise.then(() => Promise.all(promises.map((p) => p()))).then(() => undefined);
+    return clearPromise
+        .then(() => Promise.all(promises.map((p) => p())))
+        .then(() => updateSnapshots(data))
+        .then(() => undefined);
 }
 const Onyx = {
     METHOD: OnyxUtils_1.default.METHOD,

package/dist/OnyxUtils.d.ts

@@ -9,6 +9,7 @@ declare const METHOD: {
     readonly CLEAR: "clear";
 };
 type OnyxMethod = ValueOf<typeof METHOD>;
+declare function getSnapshotKey(): OnyxKey | null;
 /**
  * Getter - returns the merge queue.
  */
@@ -235,5 +236,6 @@ declare const OnyxUtils: {
     prepareKeyValuePairsForStorage: typeof prepareKeyValuePairsForStorage;
     applyMerge: typeof applyMerge;
     initializeWithDefaultKeyStates: typeof initializeWithDefaultKeyStates;
+    getSnapshotKey: typeof getSnapshotKey;
 };
 export default OnyxUtils;

package/dist/OnyxUtils.js

@@ -65,6 +65,10 @@ const evictionBlocklist = {};
 let defaultKeyStates = {};
 let batchUpdatesPromise = null;
 let batchUpdatesQueue = [];
+let snapshotKey = null;
+function getSnapshotKey() {
+    return snapshotKey;
+}
 /**
  * Getter - returns the merge queue.
  */
@@ -110,6 +114,9 @@ function initStoreValues(keys, initialKeyStates, safeEvictionKeys) {
     DevTools_1.default.initState(initialKeyStates);
     // Let Onyx know about which keys are safe to evict
     evictionAllowList = safeEvictionKeys;
+    if (typeof keys.COLLECTION === 'object' && typeof keys.COLLECTION.SNAPSHOT === 'string') {
+        snapshotKey = keys.COLLECTION.SNAPSHOT;
+    }
 }
 function sendActionToDevTools(method, key, value, mergedValue = undefined) {
     DevTools_1.default.registerAction(utils_1.default.formatActionName(method, key), value, key ? { [key]: mergedValue || value } : value);
@@ -931,5 +938,6 @@ const OnyxUtils = {
     prepareKeyValuePairsForStorage,
     applyMerge,
     initializeWithDefaultKeyStates,
+    getSnapshotKey,
 };
 exports.default = OnyxUtils;

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.49",
   "author": "Expensify, Inc.",
   "homepage": "https://expensify.com",
   "description": "State management for React Native",