react-native-onyx 3.0.132 → 3.0.134

package/dist/OnyxCache.js

@@ -22,6 +22,8 @@ const FROZEN_EMPTY_COLLECTION = Object.freeze({});
 const CACHE_MERGE_OPTIONS = {
     shouldRemoveNestedNulls: true,
     objectRemovalMode: 'replace',
+    // Keeps cached references of deep-equal arrays, so unchanged merges are no-ops.
+    shouldKeepEqualArrays: true,
 };
 // Task constants
 const TASK = {

package/dist/utils.d.ts

@@ -18,6 +18,11 @@ type FastMergeOptions = {
      * If set to "replace", we will completely replace the marked objects with the new value instead of merging them.
      */
     objectRemovalMode?: 'mark' | 'replace' | 'none';
+    /**
+     * If true, a source array deep-equal to the target array keeps the target reference, so unchanged merges return the target.
+     * Arrays inside an object are only compared when nothing else in it changed. Costs a deep comparison per array.
+     */
+    shouldKeepEqualArrays?: boolean;
 };
 type FastMergeMetadata = {
     /** The list of tuples that will be used in SQLiteProvider to replace the nested objects using `JSON_REPLACE`. */

package/dist/utils.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const fast_equals_1 = require("fast-equals");
 const ONYX_INTERNALS__REPLACE_OBJECT_MARK = 'ONYX_INTERNALS__REPLACE_OBJECT_MARK';
 /**
  * Merges two objects and removes null values if "shouldRemoveNestedNulls" is set to true
@@ -7,7 +8,7 @@ const ONYX_INTERNALS__REPLACE_OBJECT_MARK = 'ONYX_INTERNALS__REPLACE_OBJECT_MARK
  * We generally want to remove null values from objects written to disk and cache, because it decreases the amount of data stored in memory and on disk.
  */
 function fastMerge(target, source, options, metadata, basePath = []) {
-    var _a, _b;
+    var _a, _b, _c;
     if (!metadata) {
         // eslint-disable-next-line no-param-reassign
         metadata = {
@@ -18,11 +19,14 @@ function fastMerge(target, source, options, metadata, basePath = []) {
     // otherwise "mergeObject" will throw an error,
     // because it expects an object as "source"
     if (!isMergeableObject(source)) {
-        return { result: source, replaceNullPatches: metadata.replaceNullPatches };
+        // Arrays are replaced, not merged, but a deep-equal source array keeps the target reference.
+        const result = (options === null || options === void 0 ? void 0 : options.shouldKeepEqualArrays) && areDeepEqualArrays(target, source) ? target : source;
+        return { result, replaceNullPatches: metadata.replaceNullPatches };
     }
     const optionsWithDefaults = {
         shouldRemoveNestedNulls: (_a = options === null || options === void 0 ? void 0 : options.shouldRemoveNestedNulls) !== null && _a !== void 0 ? _a : false,
         objectRemovalMode: (_b = options === null || options === void 0 ? void 0 : options.objectRemovalMode) !== null && _b !== void 0 ? _b : 'none',
+        shouldKeepEqualArrays: (_c = options === null || options === void 0 ? void 0 : options.shouldKeepEqualArrays) !== null && _c !== void 0 ? _c : false,
     };
     const mergedValue = mergeObject(target, source, optionsWithDefaults, metadata, basePath);
     return { result: mergedValue, replaceNullPatches: metadata.replaceNullPatches };
@@ -42,6 +46,9 @@ function mergeObject(target, source, options, metadata, basePath) {
     // Track whether the merge actually changed anything compared to target.
     // If nothing changed, we return the original target reference for reference stability.
     let hasChanged = !targetObject;
+    // Keys whose array was replaced. Compared at the end, and only if nothing else changed,
+    // since any other change gives the object a new reference anyway.
+    let replacedArrayKeys;
     // First we want to copy over all keys from the target into the destination object,
     // in case "target" is a mergable object.
     // If "shouldRemoveNestedNulls" is true, we want to remove null values from the merged object
@@ -72,8 +79,15 @@ function mergeObject(target, source, options, metadata, basePath) {
         }
         // If the source value is not a mergable object, we need to set the key directly.
         if (!isMergeableObject(sourceProperty)) {
-            if (destination[key] !== sourceProperty) {
-                hasChanged = true;
+            const destinationProperty = destination[key];
+            if (destinationProperty !== sourceProperty) {
+                if (options.shouldKeepEqualArrays && !hasChanged && Array.isArray(destinationProperty) && Array.isArray(sourceProperty)) {
+                    replacedArrayKeys !== null && replacedArrayKeys !== void 0 ? replacedArrayKeys : (replacedArrayKeys = []);
+                    replacedArrayKeys.push(key);
+                }
+                else {
+                    hasChanged = true;
+                }
             }
             destination[key] = sourceProperty;
             continue;
@@ -105,7 +119,18 @@ function mergeObject(target, source, options, metadata, basePath) {
         }
         destination[key] = merged;
     }
-    return hasChanged ? destination : targetObject;
+    if (hasChanged) {
+        return destination;
+    }
+    // Only arrays were replaced. If they are all deep-equal, the merge is a no-op.
+    if (replacedArrayKeys) {
+        for (const key of replacedArrayKeys) {
+            if (!(0, fast_equals_1.deepEqual)(targetObject === null || targetObject === void 0 ? void 0 : targetObject[key], destination[key])) {
+                return destination;
+            }
+        }
+    }
+    return targetObject;
 }
 /** Checks whether the given object is an object and not null/undefined. */
 function isEmptyObject(obj) {
@@ -129,6 +154,10 @@ function isMergeableObject(value) {
     const isNonNullObject = value != null ? typeof value === 'object' : false;
     return isNonNullObject && !(value instanceof RegExp) && !(value instanceof Date) && !Array.isArray(value);
 }
+/** Checks whether both values are arrays with deep-equal contents. */
+function areDeepEqualArrays(a, b) {
+    return Array.isArray(a) && Array.isArray(b) && (0, fast_equals_1.deepEqual)(a, b);
+}
 /**
  * Reports whether a value needs cleaning (nested null/undefined, or the replace-object mark) before it's
  * safe to store by reference. Read-only, non-allocating.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-onyx",
-  "version": "3.0.132",
+  "version": "3.0.134",
   "author": "Expensify, Inc.",
   "homepage": "https://expensify.com",
   "description": "State management for React Native",
@@ -126,6 +126,9 @@
       "optional": true
     }
   },
+  "overrides": {
+    "simple-git": "^4.0.2"
+  },
   "engines": {
     "node": ">=20.19.5",
     "npm": ">=10.8.2"