react-native-onyx 3.0.6 → 3.0.8

package/README.md

@@ -441,7 +441,24 @@ To use the extension, simply install it from your favorite web browser store:
 - [Microsoft Edge](https://microsoftedge.microsoft.com/addons/detail/redux-devtools/nnkgneoiohoecpdiaponcejilbhhikei)
 - [Mozilla Firefox](https://addons.mozilla.org/en-US/firefox/addon/reduxdevtools/)
 
-After installing the extension, Onyx will automatically connect to it and start logging any updates made to the local storage.
+### Enabling or Disabling Redux DevTools
+
+You can control whether the Redux DevTools integration is enabled by setting the `enableDevTools` option in the `Onyx.init()` configuration.
+
+- To **enable** Redux DevTools and start logging updates to local storage, set `enableDevTools: true`.
+- To **disable** Redux DevTools and prevent any logging to the extension, set `enableDevTools: false`.
+
+This option defaults to `true` (enabled) on Web, so you only need to set it to `false` if you want to disable the integration.
+
+```javascript
+import Onyx from 'react-native-onyx';
+import Config from './config';
+
+Onyx.init({
+    keys: ONYXKEYS,
+    enableDevTools: Config.ENABLE_ONYX_DEVTOOLS,
+});
+```
 
 ### Usage
 

package/dist/DevTools/NoOpDevTools.d.ts

@@ -0,0 +1,11 @@
+import type { IDevTools } from './types';
+/**
+ * No-op implementation of DevTools that does nothing
+ * Used when DevTools is disabled
+ */
+declare class NoOpDevTools implements IDevTools {
+    registerAction(): void;
+    initState(): void;
+    clearState(): void;
+}
+export default NoOpDevTools;

package/dist/DevTools/NoOpDevTools.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * No-op implementation of DevTools that does nothing
+ * Used when DevTools is disabled
+ */
+class NoOpDevTools {
+    registerAction() {
+        // do nothing
+    }
+    initState() {
+        // do nothing
+    }
+    clearState() {
+        // do nothing
+    }
+}
+exports.default = NoOpDevTools;

package/dist/DevTools/RealDevTools.d.ts

@@ -0,0 +1,25 @@
+import type { IDevTools, DevtoolsOptions, DevtoolsConnection } from './types';
+/**
+ * Real implementation of DevTools that connects to Redux DevTools Extension
+ */
+declare class RealDevTools implements IDevTools {
+    private remoteDev?;
+    private state;
+    private defaultState;
+    constructor();
+    connectViaExtension(options?: DevtoolsOptions): DevtoolsConnection | undefined;
+    /**
+     * Registers an action that updated the current state of the storage
+     *
+     * @param type - name of the action
+     * @param payload - data written to the storage
+     * @param stateChanges - partial state that got updated after the changes
+     */
+    registerAction(type: string, payload: unknown, stateChanges?: Record<string, unknown> | null): void;
+    initState(initialState?: Record<string, unknown>): void;
+    /**
+     * This clears the internal state of the DevTools, preserving the keys included in `keysToPreserve`
+     */
+    clearState(keysToPreserve?: string[]): void;
+}
+export default RealDevTools;

package/dist/DevTools/RealDevTools.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ERROR_LABEL = 'Onyx DevTools - Error: ';
+/**
+ * Real implementation of DevTools that connects to Redux DevTools Extension
+ */
+class RealDevTools {
+    constructor() {
+        this.remoteDev = this.connectViaExtension();
+        this.state = {};
+        this.defaultState = {};
+    }
+    connectViaExtension(options) {
+        try {
+            // We don't want to augment the window type in a library code, so we use type assertion instead
+            // eslint-disable-next-line no-underscore-dangle, @typescript-eslint/no-explicit-any
+            const reduxDevtools = typeof window === 'undefined' ? undefined : window.__REDUX_DEVTOOLS_EXTENSION__;
+            if ((options === null || options === void 0 ? void 0 : options.remote) || !reduxDevtools) {
+                return;
+            }
+            return reduxDevtools.connect(options);
+        }
+        catch (e) {
+            console.error(ERROR_LABEL, e);
+        }
+    }
+    /**
+     * Registers an action that updated the current state of the storage
+     *
+     * @param type - name of the action
+     * @param payload - data written to the storage
+     * @param stateChanges - partial state that got updated after the changes
+     */
+    registerAction(type, payload, stateChanges = {}) {
+        try {
+            if (!this.remoteDev) {
+                return;
+            }
+            const newState = Object.assign(Object.assign({}, this.state), stateChanges);
+            this.remoteDev.send({ type, payload }, newState);
+            this.state = newState;
+        }
+        catch (e) {
+            console.error(ERROR_LABEL, e);
+        }
+    }
+    initState(initialState = {}) {
+        try {
+            if (!this.remoteDev) {
+                return;
+            }
+            this.remoteDev.init(initialState);
+            this.state = initialState;
+            this.defaultState = initialState;
+        }
+        catch (e) {
+            console.error(ERROR_LABEL, e);
+        }
+    }
+    /**
+     * This clears the internal state of the DevTools, preserving the keys included in `keysToPreserve`
+     */
+    clearState(keysToPreserve = []) {
+        const newState = Object.entries(this.state).reduce((obj, [key, value]) => {
+            // eslint-disable-next-line no-param-reassign
+            obj[key] = keysToPreserve.includes(key) ? value : this.defaultState[key];
+            return obj;
+        }, {});
+        this.registerAction('CLEAR', undefined, newState);
+    }
+}
+exports.default = RealDevTools;

package/dist/DevTools/types.d.ts

@@ -0,0 +1,31 @@
+type DevtoolsOptions = {
+    maxAge?: number;
+    name?: string;
+    postTimelineUpdate?: () => void;
+    preAction?: () => void;
+    logTrace?: boolean;
+    remote?: boolean;
+};
+type DevtoolsSubscriber = (message: {
+    type: string;
+    payload: unknown;
+    state: string;
+}) => void;
+type DevtoolsConnection = {
+    send(data: Record<string, unknown>, state: Record<string, unknown>): void;
+    init(state: Record<string, unknown>): void;
+    unsubscribe(): void;
+    subscribe(cb: DevtoolsSubscriber): () => void;
+};
+type ReduxDevtools = {
+    connect(options?: DevtoolsOptions): DevtoolsConnection;
+};
+/**
+ * Type definition for DevTools instance
+ */
+type IDevTools = {
+    registerAction(type: string, payload: unknown, stateChanges?: Record<string, unknown> | null): void;
+    initState(initialState?: Record<string, unknown>): void;
+    clearState(keysToPreserve?: string[]): void;
+};
+export type { DevtoolsOptions, DevtoolsSubscriber, DevtoolsConnection, ReduxDevtools, IDevTools };

package/dist/DevTools/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/DevTools.d.ts

@@ -1,42 +1,19 @@
-type DevtoolsOptions = {
-    maxAge?: number;
-    name?: string;
-    postTimelineUpdate?: () => void;
-    preAction?: () => void;
-    logTrace?: boolean;
-    remote?: boolean;
-};
-type DevtoolsSubscriber = (message: {
-    type: string;
-    payload: unknown;
-    state: string;
-}) => void;
-type DevtoolsConnection = {
-    send(data: Record<string, unknown>, state: Record<string, unknown>): void;
-    init(state: Record<string, unknown>): void;
-    unsubscribe(): void;
-    subscribe(cb: DevtoolsSubscriber): () => void;
-};
-declare class DevTools {
-    private remoteDev?;
-    private state;
-    private defaultState;
-    constructor();
-    connectViaExtension(options?: DevtoolsOptions): DevtoolsConnection | undefined;
-    /**
-     * Registers an action that updated the current state of the storage
-     *
-     * @param type - name of the action
-     * @param payload - data written to the storage
-     * @param stateChanges - partial state that got updated after the changes
-     */
-    registerAction(type: string, payload: unknown, stateChanges?: Record<string, unknown> | null): void;
-    initState(initialState?: Record<string, unknown>): void;
-    /**
-     * This clears the internal state of the DevTools, preserving the keys included in `keysToPreserve`
-     */
-    clearState(keysToPreserve?: string[]): void;
-}
-declare const _default: DevTools;
-export default _default;
-export type { DevtoolsConnection };
+import type { IDevTools, DevtoolsConnection } from './DevTools/types';
+/**
+ * Initializes DevTools with the given enabled flag
+ */
+declare function initDevTools(enabled: boolean): void;
+/**
+ * Gets the current DevTools instance (for testing purposes only)
+ * @private
+ */
+declare function getDevToolsInstance(): IDevTools;
+/**
+ * Export a default object that delegates to the current devToolsInstance
+ * This allows the instance to be swapped out while keeping the same import signature
+ */
+declare const DevTools: IDevTools;
+export default DevTools;
+export { initDevTools, getDevToolsInstance };
+export type { DevtoolsConnection, IDevTools };
+export type { default as RealDevTools } from './DevTools/RealDevTools';

package/dist/DevTools.js

@@ -1,69 +1,40 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const ERROR_LABEL = 'Onyx DevTools - Error: ';
-class DevTools {
-    constructor() {
-        this.remoteDev = this.connectViaExtension();
-        this.state = {};
-        this.defaultState = {};
-    }
-    connectViaExtension(options) {
-        try {
-            // We don't want to augment the window type in a library code, so we use type assertion instead
-            // eslint-disable-next-line no-underscore-dangle, @typescript-eslint/no-explicit-any
-            const reduxDevtools = typeof window === 'undefined' ? undefined : window.__REDUX_DEVTOOLS_EXTENSION__;
-            if ((options === null || options === void 0 ? void 0 : options.remote) || !reduxDevtools) {
-                return;
-            }
-            return reduxDevtools.connect(options);
-        }
-        catch (e) {
-            console.error(ERROR_LABEL, e);
-        }
-    }
-    /**
-     * Registers an action that updated the current state of the storage
-     *
-     * @param type - name of the action
-     * @param payload - data written to the storage
-     * @param stateChanges - partial state that got updated after the changes
-     */
+exports.initDevTools = initDevTools;
+exports.getDevToolsInstance = getDevToolsInstance;
+const RealDevTools_1 = __importDefault(require("./DevTools/RealDevTools"));
+const NoOpDevTools_1 = __importDefault(require("./DevTools/NoOpDevTools"));
+// Start with a no-op instance
+let devToolsInstance = new NoOpDevTools_1.default();
+/**
+ * Initializes DevTools with the given enabled flag
+ */
+function initDevTools(enabled) {
+    devToolsInstance = enabled ? new RealDevTools_1.default() : new NoOpDevTools_1.default();
+}
+/**
+ * Gets the current DevTools instance (for testing purposes only)
+ * @private
+ */
+function getDevToolsInstance() {
+    return devToolsInstance;
+}
+/**
+ * Export a default object that delegates to the current devToolsInstance
+ * This allows the instance to be swapped out while keeping the same import signature
+ */
+const DevTools = {
     registerAction(type, payload, stateChanges = {}) {
-        try {
-            if (!this.remoteDev) {
-                return;
-            }
-            const newState = Object.assign(Object.assign({}, this.state), stateChanges);
-            this.remoteDev.send({ type, payload }, newState);
-            this.state = newState;
-        }
-        catch (e) {
-            console.error(ERROR_LABEL, e);
-        }
-    }
+        devToolsInstance.registerAction(type, payload, stateChanges);
+    },
     initState(initialState = {}) {
-        try {
-            if (!this.remoteDev) {
-                return;
-            }
-            this.remoteDev.init(initialState);
-            this.state = initialState;
-            this.defaultState = initialState;
-        }
-        catch (e) {
-            console.error(ERROR_LABEL, e);
-        }
-    }
-    /**
-     * This clears the internal state of the DevTools, preserving the keys included in `keysToPreserve`
-     */
+        devToolsInstance.initState(initialState);
+    },
     clearState(keysToPreserve = []) {
-        const newState = Object.entries(this.state).reduce((obj, [key, value]) => {
-            // eslint-disable-next-line no-param-reassign
-            obj[key] = keysToPreserve.includes(key) ? value : this.defaultState[key];
-            return obj;
-        }, {});
-        this.registerAction('CLEAR', undefined, newState);
-    }
-}
-exports.default = new DevTools();
+        devToolsInstance.clearState(keysToPreserve);
+    },
+};
+exports.default = DevTools;

package/dist/Onyx.d.ts

@@ -2,7 +2,7 @@ import * as Logger from './Logger';
 import type { CollectionKeyBase, ConnectOptions, InitOptions, OnyxKey, OnyxMergeCollectionInput, OnyxMergeInput, OnyxMultiSetInput, OnyxSetInput, OnyxUpdate, SetOptions } from './types';
 import type { Connection } from './OnyxConnectionManager';
 /** Initialize the store with actions and listening for storage events */
-declare function init({ keys, initialKeyStates, evictableKeys, maxCachedKeysCount, shouldSyncMultipleInstances, enablePerformanceMetrics, skippableCollectionMemberIDs, }: InitOptions): void;
+declare function init({ keys, initialKeyStates, evictableKeys, maxCachedKeysCount, shouldSyncMultipleInstances, enablePerformanceMetrics, enableDevTools, skippableCollectionMemberIDs, }: InitOptions): void;
 /**
  * Connects to an Onyx key given the options passed and listens to its changes.
  * This method will be deprecated soon. Please use `Onyx.connectWithoutView()` instead.

package/dist/Onyx.js

@@ -40,7 +40,7 @@ const Logger = __importStar(require("./Logger"));
 const OnyxCache_1 = __importStar(require("./OnyxCache"));
 const storage_1 = __importDefault(require("./storage"));
 const utils_1 = __importDefault(require("./utils"));
-const DevTools_1 = __importDefault(require("./DevTools"));
+const DevTools_1 = __importStar(require("./DevTools"));
 const OnyxUtils_1 = __importDefault(require("./OnyxUtils"));
 const logMessages_1 = __importDefault(require("./logMessages"));
 const OnyxConnectionManager_1 = __importDefault(require("./OnyxConnectionManager"));
@@ -48,12 +48,13 @@ const GlobalSettings = __importStar(require("./GlobalSettings"));
 const metrics_1 = __importDefault(require("./metrics"));
 const OnyxMerge_1 = __importDefault(require("./OnyxMerge"));
 /** Initialize the store with actions and listening for storage events */
-function init({ keys = {}, initialKeyStates = {}, evictableKeys = [], maxCachedKeysCount = 1000, shouldSyncMultipleInstances = !!global.localStorage, enablePerformanceMetrics = false, skippableCollectionMemberIDs = [], }) {
+function init({ keys = {}, initialKeyStates = {}, evictableKeys = [], maxCachedKeysCount = 1000, shouldSyncMultipleInstances = !!global.localStorage, enablePerformanceMetrics = false, enableDevTools = true, skippableCollectionMemberIDs = [], }) {
     var _a;
     if (enablePerformanceMetrics) {
         GlobalSettings.setPerformanceMetricsEnabled(true);
         applyDecorators();
     }
+    (0, DevTools_1.initDevTools)(enableDevTools);
     storage_1.default.init();
     OnyxUtils_1.default.setSkippableCollectionMemberIDs(new Set(skippableCollectionMemberIDs));
     if (shouldSyncMultipleInstances) {
@@ -343,7 +344,7 @@ function merge(key, changes) {
  * @param collection Object collection keyed by individual collection member keys and values
  */
 function mergeCollection(collectionKey, collection) {
-    return OnyxUtils_1.default.mergeCollectionWithPatches(collectionKey, collection);
+    return OnyxUtils_1.default.mergeCollectionWithPatches(collectionKey, collection, undefined, true);
 }
 /**
  * Clear out all the data in the store
@@ -552,7 +553,7 @@ function update(data) {
             set: {},
         });
         if (!utils_1.default.isEmptyObject(batchedCollectionUpdates.merge)) {
-            promises.push(() => OnyxUtils_1.default.mergeCollectionWithPatches(collectionKey, batchedCollectionUpdates.merge, batchedCollectionUpdates.mergeReplaceNullPatches));
+            promises.push(() => OnyxUtils_1.default.mergeCollectionWithPatches(collectionKey, batchedCollectionUpdates.merge, batchedCollectionUpdates.mergeReplaceNullPatches, true));
         }
         if (!utils_1.default.isEmptyObject(batchedCollectionUpdates.set)) {
             promises.push(() => OnyxUtils_1.default.partialSetCollection(collectionKey, batchedCollectionUpdates.set));
@@ -623,7 +624,7 @@ function setCollection(collectionKey, collection) {
             }
             mutableCollection[key] = null;
         });
-        const keyValuePairs = OnyxUtils_1.default.prepareKeyValuePairsForStorage(mutableCollection, true);
+        const keyValuePairs = OnyxUtils_1.default.prepareKeyValuePairsForStorage(mutableCollection, true, undefined, true);
         const previousCollection = OnyxUtils_1.default.getCachedCollection(collectionKey);
         keyValuePairs.forEach(([key, value]) => OnyxCache_1.default.set(key, value));
         const updatePromise = OnyxUtils_1.default.scheduleNotifyCollectionSubscribers(collectionKey, mutableCollection, previousCollection);

package/dist/OnyxUtils.d.ts

@@ -149,7 +149,7 @@ declare function keysChanged<TKey extends CollectionKeyBase>(collectionKey: TKey
  * @example
  * keyChanged(key, value, subscriber => subscriber.initWithStoredValues === false)
  */
-declare function keyChanged<TKey extends OnyxKey>(key: TKey, value: OnyxValue<TKey>, canUpdateSubscriber?: (subscriber?: CallbackToStateMapping<OnyxKey>) => boolean, notifyConnectSubscribers?: boolean): void;
+declare function keyChanged<TKey extends OnyxKey>(key: TKey, value: OnyxValue<TKey>, canUpdateSubscriber?: (subscriber?: CallbackToStateMapping<OnyxKey>) => boolean, notifyConnectSubscribers?: boolean, isProcessingCollectionUpdate?: boolean): void;
 /**
  * Sends the data obtained from the keys to the connection.
  */
@@ -169,7 +169,7 @@ declare function getCollectionDataAndSendAsObject<TKey extends OnyxKey>(matching
  * @example
  * scheduleSubscriberUpdate(key, value, subscriber => subscriber.initWithStoredValues === false)
  */
-declare function scheduleSubscriberUpdate<TKey extends OnyxKey>(key: TKey, value: OnyxValue<TKey>, canUpdateSubscriber?: (subscriber?: CallbackToStateMapping<OnyxKey>) => boolean): Promise<void>;
+declare function scheduleSubscriberUpdate<TKey extends OnyxKey>(key: TKey, value: OnyxValue<TKey>, canUpdateSubscriber?: (subscriber?: CallbackToStateMapping<OnyxKey>) => boolean, isProcessingCollectionUpdate?: boolean): Promise<void>;
 /**
  * This method is similar to notifySubscribersOnNextTick but it is built for working specifically with collections
  * so that keysChanged() is triggered for the collection and not keyChanged(). If this was not done, then the
@@ -179,7 +179,7 @@ declare function scheduleNotifyCollectionSubscribers<TKey extends OnyxKey>(key:
 /**
  * Remove a key from Onyx and update the subscribers
  */
-declare function remove<TKey extends OnyxKey>(key: TKey): Promise<void>;
+declare function remove<TKey extends OnyxKey>(key: TKey, isProcessingCollectionUpdate?: boolean): Promise<void>;
 declare function reportStorageQuota(): Promise<void>;
 /**
  * If we fail to set or merge we must handle this by
@@ -199,7 +199,7 @@ declare function hasPendingMergeForKey(key: OnyxKey): boolean;
  *
  * @return an array of key - value pairs <[key, value]>
  */
-declare function prepareKeyValuePairsForStorage(data: Record<OnyxKey, OnyxInput<OnyxKey>>, shouldRemoveNestedNulls?: boolean, replaceNullPatches?: MultiMergeReplaceNullPatches): StorageKeyValuePair[];
+declare function prepareKeyValuePairsForStorage(data: Record<OnyxKey, OnyxInput<OnyxKey>>, shouldRemoveNestedNulls?: boolean, replaceNullPatches?: MultiMergeReplaceNullPatches, isProcessingCollectionUpdate?: boolean): StorageKeyValuePair[];
 /**
  * Merges an array of changes with an existing value or creates a single change.
  *
@@ -251,7 +251,7 @@ declare function updateSnapshots(data: OnyxUpdate[], mergeFn: typeof Onyx.merge)
  * @param mergeReplaceNullPatches Record where the key is a collection member key and the value is a list of
  * tuples that we'll use to replace the nested objects of that collection member record with something else.
  */
-declare function mergeCollectionWithPatches<TKey extends CollectionKeyBase, TMap>(collectionKey: TKey, collection: OnyxMergeCollectionInput<TKey, TMap>, mergeReplaceNullPatches?: MultiMergeReplaceNullPatches): Promise<void>;
+declare function mergeCollectionWithPatches<TKey extends CollectionKeyBase, TMap>(collectionKey: TKey, collection: OnyxMergeCollectionInput<TKey, TMap>, mergeReplaceNullPatches?: MultiMergeReplaceNullPatches, isProcessingCollectionUpdate?: boolean): Promise<void>;
 /**
  * Sets keys in a collection by replacing all targeted collection members with new values.
  * Any existing collection members not included in the new data will not be removed.

package/dist/OnyxUtils.js

@@ -564,7 +564,7 @@ function keysChanged(collectionKey, partialCollection, partialPreviousCollection
  * @example
  * keyChanged(key, value, subscriber => subscriber.initWithStoredValues === false)
  */
-function keyChanged(key, value, canUpdateSubscriber = () => true, notifyConnectSubscribers = true) {
+function keyChanged(key, value, canUpdateSubscriber = () => true, notifyConnectSubscribers = true, isProcessingCollectionUpdate = false) {
     var _a, _b;
     // Add or remove this key from the recentlyAccessedKeys lists
     if (value !== null) {
@@ -609,6 +609,11 @@ function keyChanged(key, value, canUpdateSubscriber = () => true, notifyConnectS
                 continue;
             }
             if (isCollectionKey(subscriber.key) && subscriber.waitForCollectionCallback) {
+                // Skip individual key changes for collection callbacks during collection updates
+                // to prevent duplicate callbacks - the collection update will handle this properly
+                if (isProcessingCollectionUpdate) {
+                    continue;
+                }
                 let cachedCollection = cachedCollections[subscriber.key];
                 if (!cachedCollection) {
                     cachedCollection = getCachedCollection(subscriber.key);
@@ -674,9 +679,9 @@ function getCollectionDataAndSendAsObject(matchingKeys, mapping) {
  * @example
  * scheduleSubscriberUpdate(key, value, subscriber => subscriber.initWithStoredValues === false)
  */
-function scheduleSubscriberUpdate(key, value, canUpdateSubscriber = () => true) {
-    const promise = Promise.resolve().then(() => keyChanged(key, value, canUpdateSubscriber, true));
-    batchUpdates(() => keyChanged(key, value, canUpdateSubscriber, false));
+function scheduleSubscriberUpdate(key, value, canUpdateSubscriber = () => true, isProcessingCollectionUpdate = false) {
+    const promise = Promise.resolve().then(() => keyChanged(key, value, canUpdateSubscriber, true, isProcessingCollectionUpdate));
+    batchUpdates(() => keyChanged(key, value, canUpdateSubscriber, false, isProcessingCollectionUpdate));
     return Promise.all([maybeFlushBatchUpdates(), promise]).then(() => undefined);
 }
 /**
@@ -692,9 +697,9 @@ function scheduleNotifyCollectionSubscribers(key, value, previousValue) {
 /**
  * Remove a key from Onyx and update the subscribers
  */
-function remove(key) {
+function remove(key, isProcessingCollectionUpdate) {
     OnyxCache_1.default.drop(key);
-    scheduleSubscriberUpdate(key, undefined);
+    scheduleSubscriberUpdate(key, undefined, undefined, isProcessingCollectionUpdate);
     return storage_1.default.removeItem(key).then(() => undefined);
 }
 function reportStorageQuota() {
@@ -756,11 +761,11 @@ function hasPendingMergeForKey(key) {
  *
  * @return an array of key - value pairs <[key, value]>
  */
-function prepareKeyValuePairsForStorage(data, shouldRemoveNestedNulls, replaceNullPatches) {
+function prepareKeyValuePairsForStorage(data, shouldRemoveNestedNulls, replaceNullPatches, isProcessingCollectionUpdate) {
     const pairs = [];
     Object.entries(data).forEach(([key, value]) => {
         if (value === null) {
-            remove(key);
+            remove(key, isProcessingCollectionUpdate);
             return;
         }
         const valueWithoutNestedNullValues = (shouldRemoveNestedNulls !== null && shouldRemoveNestedNulls !== void 0 ? shouldRemoveNestedNulls : true) ? utils_1.default.removeNestedNullValues(value) : value;
@@ -1010,7 +1015,7 @@ function updateSnapshots(data, mergeFn) {
  * @param mergeReplaceNullPatches Record where the key is a collection member key and the value is a list of
  * tuples that we'll use to replace the nested objects of that collection member record with something else.
  */
-function mergeCollectionWithPatches(collectionKey, collection, mergeReplaceNullPatches) {
+function mergeCollectionWithPatches(collectionKey, collection, mergeReplaceNullPatches, isProcessingCollectionUpdate = false) {
     if (!isValidNonEmptyCollectionForMerge(collection)) {
         Logger.logInfo('mergeCollection() called with invalid or empty value. Skipping this update.');
         return Promise.resolve();
@@ -1043,7 +1048,7 @@ function mergeCollectionWithPatches(collectionKey, collection, mergeReplaceNullP
         // Split to keys that exist in storage and keys that don't
         const keys = resultCollectionKeys.filter((key) => {
             if (resultCollection[key] === null) {
-                remove(key);
+                remove(key, isProcessingCollectionUpdate);
                 return false;
             }
             return true;
@@ -1139,7 +1144,7 @@ function partialSetCollection(collectionKey, collection) {
         const mutableCollection = Object.assign({}, resultCollection);
         const existingKeys = resultCollectionKeys.filter((key) => persistedKeys.has(key));
         const previousCollection = getCachedCollection(collectionKey, existingKeys);
-        const keyValuePairs = prepareKeyValuePairsForStorage(mutableCollection, true);
+        const keyValuePairs = prepareKeyValuePairsForStorage(mutableCollection, true, undefined, true);
         keyValuePairs.forEach(([key, value]) => OnyxCache_1.default.set(key, value));
         const updatePromise = scheduleNotifyCollectionSubscribers(collectionKey, mutableCollection, previousCollection);
         return storage_1.default.multiSet(keyValuePairs)

package/dist/types.d.ts

@@ -337,6 +337,12 @@ type InitOptions = {
      * @default false
      */
     enablePerformanceMetrics?: boolean;
+    /**
+     * If enabled, it will connect to Redux DevTools Extension for debugging.
+     * This allows you to see all Onyx state changes in the Redux DevTools.
+     * @default true
+     */
+    enableDevTools?: boolean;
     /**
      * Array of collection member IDs which updates will be ignored when using Onyx methods.
      * Additionally, any subscribers from these keys to won't receive any data from Onyx.

package/package.json

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