react-native-onyx 3.0.9 → 3.0.11

package/dist/Onyx.d.ts

@@ -1,5 +1,5 @@
 import * as Logger from './Logger';
-import type { CollectionKeyBase, ConnectOptions, InitOptions, OnyxKey, OnyxMergeCollectionInput, OnyxMergeInput, OnyxMultiSetInput, OnyxSetInput, OnyxUpdate, SetOptions } from './types';
+import type { CollectionKeyBase, ConnectOptions, InitOptions, OnyxKey, OnyxMergeCollectionInput, OnyxSetCollectionInput, 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, enableDevTools, skippableCollectionMemberIDs, }: InitOptions): void;
@@ -110,7 +110,7 @@ declare function merge<TKey extends OnyxKey>(key: TKey, changes: OnyxMergeInput<
  * @param collectionKey e.g. `ONYXKEYS.COLLECTION.REPORT`
  * @param collection Object collection keyed by individual collection member keys and values
  */
-declare function mergeCollection<TKey extends CollectionKeyBase, TMap>(collectionKey: TKey, collection: OnyxMergeCollectionInput<TKey, TMap>): Promise<void>;
+declare function mergeCollection<TKey extends CollectionKeyBase>(collectionKey: TKey, collection: OnyxMergeCollectionInput<TKey>): Promise<void>;
 /**
  * Clear out all the data in the store
  *
@@ -153,7 +153,7 @@ declare function update(data: OnyxUpdate[]): Promise<void>;
  * @param collectionKey e.g. `ONYXKEYS.COLLECTION.REPORT`
  * @param collection Object collection keyed by individual collection member keys and values
  */
-declare function setCollection<TKey extends CollectionKeyBase, TMap>(collectionKey: TKey, collection: OnyxMergeCollectionInput<TKey, TMap>): Promise<void>;
+declare function setCollection<TKey extends CollectionKeyBase>(collectionKey: TKey, collection: OnyxSetCollectionInput<TKey>): Promise<void>;
 declare const Onyx: {
     METHOD: {
         readonly SET: "set";

package/dist/Onyx.js

@@ -626,8 +626,9 @@ function setCollection(collectionKey, collection) {
         });
         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);
+        // Preserve references for unchanged items in setCollection
+        const preservedCollection = OnyxUtils_1.default.preserveCollectionReferences(keyValuePairs);
+        const updatePromise = OnyxUtils_1.default.scheduleNotifyCollectionSubscribers(collectionKey, preservedCollection, previousCollection);
         return storage_1.default.multiSet(keyValuePairs)
             .catch((error) => OnyxUtils_1.default.evictStorageAndRetry(error, setCollection, collectionKey, collection))
             .then(() => {

package/dist/OnyxUtils.d.ts

@@ -1,6 +1,6 @@
 import type { ValueOf } from 'type-fest';
 import type Onyx from './Onyx';
-import type { CollectionKey, CollectionKeyBase, ConnectOptions, DeepRecord, KeyValueMapping, CallbackToStateMapping, MultiMergeReplaceNullPatches, OnyxCollection, OnyxEntry, OnyxInput, OnyxKey, OnyxMergeCollectionInput, OnyxUpdate, OnyxValue, Selector } from './types';
+import type { CollectionKey, CollectionKeyBase, ConnectOptions, DeepRecord, KeyValueMapping, CallbackToStateMapping, MultiMergeReplaceNullPatches, OnyxCollection, OnyxEntry, OnyxInput, OnyxInputKeyValueMapping, OnyxKey, OnyxMergeCollectionInput, OnyxUpdate, OnyxValue, Selector, OnyxSetCollectionInput } from './types';
 import type { FastMergeResult } from './utils';
 import type { DeferredTask } from './createDeferredTask';
 import type { StorageKeyValuePair } from './storage/providers/types';
@@ -138,6 +138,18 @@ declare function getCollectionKey(key: CollectionKey): string;
  * If the requested key is a collection, it will return an object with all the collection members.
  */
 declare function tryGetCachedValue<TKey extends OnyxKey>(key: TKey): OnyxValue<OnyxKey>;
+/**
+ * Utility function to preserve object references for unchanged items in collection operations.
+ * Compares new values with cached values using deep equality and preserves references when data is identical.
+ * @returns The preserved collection with unchanged references maintained
+ */
+declare function preserveCollectionReferences(keyValuePairs: StorageKeyValuePair[]): OnyxInputKeyValueMapping;
+/**
+ * Utility function for merge operations that preserves references after cache merge has been performed.
+ * Compares merged values with original cached values and preserves references when data is unchanged.
+ * @returns The preserved collection with unchanged references maintained
+ */
+declare function preserveCollectionReferencesAfterMerge(collection: Record<string, OnyxValue<OnyxKey>>, originalCachedValues: Record<string, OnyxValue<OnyxKey>>): Record<string, OnyxValue<OnyxKey>>;
 declare function getCachedCollection<TKey extends CollectionKeyBase>(collectionKey: TKey, collectionMemberKeys?: string[]): NonNullable<OnyxCollection<KeyValueMapping[TKey]>>;
 /**
  * When a collection of keys change, search for any callbacks matching the collection key and trigger those callbacks
@@ -222,7 +234,7 @@ declare function initializeWithDefaultKeyStates(): Promise<void>;
 /**
  * Validate the collection is not empty and has a correct type before applying mergeCollection()
  */
-declare function isValidNonEmptyCollectionForMerge<TKey extends CollectionKeyBase, TMap>(collection: OnyxMergeCollectionInput<TKey, TMap>): boolean;
+declare function isValidNonEmptyCollectionForMerge<TKey extends CollectionKeyBase>(collection: OnyxMergeCollectionInput<TKey>): boolean;
 /**
  * Verify if all the collection keys belong to the same parent
  */
@@ -251,7 +263,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, isProcessingCollectionUpdate?: boolean): Promise<void>;
+declare function mergeCollectionWithPatches<TKey extends CollectionKeyBase>(collectionKey: TKey, collection: OnyxMergeCollectionInput<TKey>, 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.
@@ -259,7 +271,7 @@ declare function mergeCollectionWithPatches<TKey extends CollectionKeyBase, TMap
  * @param collectionKey e.g. `ONYXKEYS.COLLECTION.REPORT`
  * @param collection Object collection keyed by individual collection member keys and values
  */
-declare function partialSetCollection<TKey extends CollectionKeyBase, TMap>(collectionKey: TKey, collection: OnyxMergeCollectionInput<TKey, TMap>): Promise<void>;
+declare function partialSetCollection<TKey extends CollectionKeyBase>(collectionKey: TKey, collection: OnyxSetCollectionInput<TKey>): Promise<void>;
 declare function logKeyChanged(onyxMethod: Extract<OnyxMethod, 'set' | 'merge'>, key: OnyxKey, value: unknown, hasChanged: boolean): void;
 declare function logKeyRemoved(onyxMethod: Extract<OnyxMethod, 'set' | 'merge'>, key: OnyxKey): void;
 /**
@@ -324,6 +336,8 @@ declare const OnyxUtils: {
     updateSnapshots: typeof updateSnapshots;
     mergeCollectionWithPatches: typeof mergeCollectionWithPatches;
     partialSetCollection: typeof partialSetCollection;
+    preserveCollectionReferences: typeof preserveCollectionReferences;
+    preserveCollectionReferencesAfterMerge: typeof preserveCollectionReferencesAfterMerge;
     logKeyChanged: typeof logKeyChanged;
     logKeyRemoved: typeof logKeyRemoved;
 };

package/dist/OnyxUtils.js

@@ -452,6 +452,51 @@ function tryGetCachedValue(key) {
     }
     return val;
 }
+/**
+ * Utility function to preserve object references for unchanged items in collection operations.
+ * Compares new values with cached values using deep equality and preserves references when data is identical.
+ * @returns The preserved collection with unchanged references maintained
+ */
+function preserveCollectionReferences(keyValuePairs) {
+    const preservedCollection = {};
+    keyValuePairs.forEach(([key, value]) => {
+        const cachedValue = OnyxCache_1.default.get(key, false);
+        // If no cached value exists, we need to add the new value (skip expensive deep equality check)
+        // Use deep equality check to preserve references for unchanged items
+        if (cachedValue !== undefined && (0, fast_equals_1.deepEqual)(value, cachedValue)) {
+            // Keep the existing reference
+            preservedCollection[key] = cachedValue;
+        }
+        else {
+            // Update cache only for changed items
+            OnyxCache_1.default.set(key, value);
+            preservedCollection[key] = value;
+        }
+    });
+    return preservedCollection;
+}
+/**
+ * Utility function for merge operations that preserves references after cache merge has been performed.
+ * Compares merged values with original cached values and preserves references when data is unchanged.
+ * @returns The preserved collection with unchanged references maintained
+ */
+function preserveCollectionReferencesAfterMerge(collection, originalCachedValues) {
+    const preservedCollection = {};
+    Object.keys(collection).forEach((key) => {
+        const newMergedValue = OnyxCache_1.default.get(key, false);
+        const originalValue = originalCachedValues[key];
+        // Use deep equality check to preserve references for unchanged items
+        if (originalValue !== undefined && (0, fast_equals_1.deepEqual)(newMergedValue, originalValue)) {
+            // Keep the existing reference and update cache
+            preservedCollection[key] = originalValue;
+            OnyxCache_1.default.set(key, originalValue);
+        }
+        else {
+            preservedCollection[key] = newMergedValue;
+        }
+    });
+    return preservedCollection;
+}
 function getCachedCollection(collectionKey, collectionMemberKeys) {
     // Use optimized collection data retrieval when cache is populated
     const collectionData = OnyxCache_1.default.getCollectionData(collectionKey);
@@ -1094,10 +1139,18 @@ function mergeCollectionWithPatches(collectionKey, collection, mergeReplaceNullP
         // finalMergedCollection contains all the keys that were merged, without the keys of incompatible updates
         const finalMergedCollection = Object.assign(Object.assign({}, existingKeyCollection), newCollection);
         // Prefill cache if necessary by calling get() on any existing keys and then merge original data to cache
-        // and update all subscribers
+        // and update all subscribers with reference preservation for unchanged items
         const promiseUpdate = previousCollectionPromise.then((previousCollection) => {
+            // Capture the original cached values before merging
+            const originalCachedValues = {};
+            Object.keys(finalMergedCollection).forEach((key) => {
+                originalCachedValues[key] = OnyxCache_1.default.get(key, false);
+            });
+            // Then merge all the data into cache as normal
             OnyxCache_1.default.merge(finalMergedCollection);
-            return scheduleNotifyCollectionSubscribers(collectionKey, finalMergedCollection, previousCollection);
+            // Finally, preserve references for items that didn't actually change
+            const preservedCollection = preserveCollectionReferencesAfterMerge(finalMergedCollection, originalCachedValues);
+            return scheduleNotifyCollectionSubscribers(collectionKey, preservedCollection, previousCollection);
         });
         return Promise.all(promises)
             .catch((error) => evictStorageAndRetry(error, mergeCollectionWithPatches, collectionKey, resultCollection))
@@ -1145,8 +1198,9 @@ function partialSetCollection(collectionKey, collection) {
         const existingKeys = resultCollectionKeys.filter((key) => persistedKeys.has(key));
         const previousCollection = getCachedCollection(collectionKey, existingKeys);
         const keyValuePairs = prepareKeyValuePairsForStorage(mutableCollection, true, undefined, true);
-        keyValuePairs.forEach(([key, value]) => OnyxCache_1.default.set(key, value));
-        const updatePromise = scheduleNotifyCollectionSubscribers(collectionKey, mutableCollection, previousCollection);
+        // Preserve references for unchanged items in partialSetCollection
+        const preservedCollection = preserveCollectionReferences(keyValuePairs);
+        const updatePromise = scheduleNotifyCollectionSubscribers(collectionKey, preservedCollection, previousCollection);
         return storage_1.default.multiSet(keyValuePairs)
             .catch((error) => evictStorageAndRetry(error, partialSetCollection, collectionKey, collection))
             .then(() => {
@@ -1223,6 +1277,8 @@ const OnyxUtils = {
     updateSnapshots,
     mergeCollectionWithPatches,
     partialSetCollection,
+    preserveCollectionReferences,
+    preserveCollectionReferencesAfterMerge,
     logKeyChanged,
     logKeyRemoved,
 };

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 import type { ConnectOptions, OnyxUpdate } from './Onyx';
 import Onyx from './Onyx';
-import type { CustomTypeOptions, KeyValueMapping, NullishDeep, OnyxCollection, OnyxEntry, OnyxKey, OnyxValue, Selector, OnyxInputValue, OnyxCollectionInputValue, OnyxInput, OnyxSetInput, OnyxMultiSetInput, OnyxMergeInput, OnyxMergeCollectionInput } from './types';
+import type { CustomTypeOptions, KeyValueMapping, NullishDeep, OnyxCollection, OnyxEntry, OnyxKey, OnyxValue, Selector, OnyxInputValue, OnyxCollectionInputValue, OnyxInput, OnyxSetInput, OnyxMultiSetInput, OnyxMergeInput, OnyxMergeCollectionInput, OnyxSetCollectionInput } from './types';
 import type { FetchStatus, ResultMetadata, UseOnyxResult, UseOnyxOptions } from './useOnyx';
 import type { Connection } from './OnyxConnectionManager';
 import useOnyx from './useOnyx';
 import type { OnyxSQLiteKeyValuePair } from './storage/providers/SQLiteProvider';
 export default Onyx;
 export { useOnyx };
-export type { ConnectOptions, CustomTypeOptions, FetchStatus, KeyValueMapping, NullishDeep, OnyxCollection, OnyxEntry, OnyxKey, OnyxInputValue, OnyxCollectionInputValue, OnyxInput, OnyxSetInput, OnyxMultiSetInput, OnyxMergeInput, OnyxMergeCollectionInput, OnyxUpdate, OnyxValue, ResultMetadata, Selector, UseOnyxResult, Connection, UseOnyxOptions, OnyxSQLiteKeyValuePair, };
+export type { ConnectOptions, CustomTypeOptions, FetchStatus, KeyValueMapping, NullishDeep, OnyxCollection, OnyxEntry, OnyxKey, OnyxInputValue, OnyxCollectionInputValue, OnyxInput, OnyxSetInput, OnyxMultiSetInput, OnyxMergeInput, OnyxMergeCollectionInput, OnyxSetCollectionInput, OnyxUpdate, OnyxValue, ResultMetadata, Selector, UseOnyxResult, Connection, UseOnyxOptions, OnyxSQLiteKeyValuePair, };

package/dist/types.d.ts

@@ -1,5 +1,4 @@
 import type { Merge } from 'type-fest';
-import type { BuiltIns } from 'type-fest/source/internal';
 import type OnyxUtils from './OnyxUtils';
 import type { OnyxMethod } from './OnyxUtils';
 import type { FastMergeReplaceNullPatch } from './utils';
@@ -138,6 +137,8 @@ type KeyValueMapping = {
 type OnyxValue<TKey extends OnyxKey> = string extends TKey ? unknown : TKey extends CollectionKeyBase ? OnyxCollection<KeyValueMapping[TKey]> : OnyxEntry<KeyValueMapping[TKey]>;
 /** Utility type to extract `TOnyxValue` from `OnyxCollection<TOnyxValue>` */
 type ExtractOnyxCollectionValue<TOnyxCollection> = TOnyxCollection extends NonNullable<OnyxCollection<infer U>> ? U : never;
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+type BuiltIns = Primitive | void | Date | RegExp;
 type NonTransformableTypes = BuiltIns | ((...args: any[]) => unknown) | Map<unknown, unknown> | Set<unknown> | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> | unknown[] | readonly unknown[];
 /**
  * Create a type from another type with all keys and nested keys set to optional or null.
@@ -174,8 +175,8 @@ type NullishObjectDeep<ObjectType extends object> = {
  * Also, the `TMap` type is inferred automatically in `mergeCollection()` method and represents
  * the object of collection keys/values specified in the second parameter of the method.
  */
-type Collection<TKey extends CollectionKeyBase, TValue, TMap = never> = {
-    [MapK in keyof TMap]: MapK extends `${TKey}${string}` ? MapK extends `${TKey}` ? never : TValue : never;
+type Collection<TKey extends CollectionKeyBase, TValue> = Record<`${TKey}${string}`, TValue> & {
+    [P in TKey]?: never;
 };
 /** Represents the base options used in `Onyx.connect()` method. */
 type BaseConnectOptions = {
@@ -263,44 +264,46 @@ type OnyxMergeInput<TKey extends OnyxKey> = OnyxInput<TKey>;
 /**
  * This represents the value that can be passed to `Onyx.merge` and to `Onyx.update` with the method "MERGE"
  */
-type OnyxMergeCollectionInput<TKey extends OnyxKey, TMap = object> = Collection<TKey, NonNullable<OnyxInput<TKey>>, TMap>;
+type OnyxMergeCollectionInput<TKey extends OnyxKey> = Collection<TKey, NonNullable<OnyxInput<TKey>>>;
+/**
+ * This represents the value that can be passed to `Onyx.setCollection` and to `Onyx.update` with the method "SET_COLLECTION"
+ */
+type OnyxSetCollectionInput<TKey extends OnyxKey> = Collection<TKey, OnyxInput<TKey>>;
 type OnyxMethodMap = typeof OnyxUtils.METHOD;
-type OnyxMethodValueMap = {
-    [OnyxUtils.METHOD.SET]: {
-        key: OnyxKey;
-        value: OnyxSetInput<OnyxKey>;
-    };
-    [OnyxUtils.METHOD.MULTI_SET]: {
-        key: OnyxKey;
-        value: OnyxMultiSetInput;
-    };
-    [OnyxUtils.METHOD.MERGE]: {
-        key: OnyxKey;
-        value: OnyxMergeInput<OnyxKey>;
-    };
-    [OnyxUtils.METHOD.CLEAR]: {
-        key: OnyxKey;
-        value?: undefined;
-    };
-    [OnyxUtils.METHOD.MERGE_COLLECTION]: {
-        key: CollectionKeyBase;
-        value: OnyxMergeCollectionInput<CollectionKeyBase>;
-    };
-    [OnyxUtils.METHOD.SET_COLLECTION]: {
-        key: CollectionKeyBase;
-        value: OnyxMergeCollectionInput<CollectionKeyBase>;
-    };
-};
 /**
  * OnyxUpdate type includes all onyx methods used in OnyxMethodValueMap.
  * If a new method is added to OnyxUtils.METHOD constant, it must be added to OnyxMethodValueMap type.
  * Otherwise it will show static type errors.
  */
 type OnyxUpdate = {
-    [Method in OnyxMethod]: {
-        onyxMethod: Method;
-    } & OnyxMethodValueMap[Method];
-}[OnyxMethod];
+    [TKey in OnyxKey]: {
+        onyxMethod: typeof OnyxUtils.METHOD.SET;
+        key: TKey;
+        value: OnyxSetInput<TKey>;
+    } | {
+        onyxMethod: typeof OnyxUtils.METHOD.MULTI_SET;
+        key: TKey;
+        value: OnyxMultiSetInput;
+    } | {
+        onyxMethod: typeof OnyxUtils.METHOD.MERGE;
+        key: TKey;
+        value: OnyxMergeInput<TKey>;
+    } | {
+        onyxMethod: typeof OnyxUtils.METHOD.CLEAR;
+        key: TKey;
+        value?: undefined;
+    };
+}[OnyxKey] | {
+    [TKey in CollectionKeyBase]: {
+        onyxMethod: typeof OnyxUtils.METHOD.MERGE_COLLECTION;
+        key: TKey;
+        value: OnyxMergeCollectionInput<TKey>;
+    } | {
+        onyxMethod: typeof OnyxUtils.METHOD.SET_COLLECTION;
+        key: TKey;
+        value: OnyxSetCollectionInput<TKey>;
+    };
+}[CollectionKeyBase];
 /**
  * Represents the options used in `Onyx.set()` method.
  */
@@ -365,4 +368,4 @@ type MixedOperationsQueue = {
     mergeReplaceNullPatches: MultiMergeReplaceNullPatches;
     set: OnyxInputKeyValueMapping;
 };
-export type { BaseConnectOptions, Collection, CollectionConnectCallback, CollectionConnectOptions, CollectionKey, CollectionKeyBase, ConnectOptions, CustomTypeOptions, DeepRecord, DefaultConnectCallback, DefaultConnectOptions, ExtractOnyxCollectionValue, GenericFunction, InitOptions, Key, KeyValueMapping, CallbackToStateMapping, NonNull, NonUndefined, OnyxInputKeyValueMapping, NullishDeep, OnyxCollection, OnyxEntry, OnyxKey, OnyxInputValue, OnyxCollectionInputValue, OnyxInput, OnyxSetInput, OnyxMultiSetInput, OnyxMergeInput, OnyxMergeCollectionInput, OnyxMethod, OnyxMethodMap, OnyxUpdate, OnyxValue, Selector, SetOptions, MultiMergeReplaceNullPatches, MixedOperationsQueue, };
+export type { BaseConnectOptions, Collection, CollectionConnectCallback, CollectionConnectOptions, CollectionKey, CollectionKeyBase, ConnectOptions, CustomTypeOptions, DeepRecord, DefaultConnectCallback, DefaultConnectOptions, ExtractOnyxCollectionValue, GenericFunction, InitOptions, Key, KeyValueMapping, CallbackToStateMapping, NonNull, NonUndefined, OnyxInputKeyValueMapping, NullishDeep, OnyxCollection, OnyxEntry, OnyxKey, OnyxInputValue, OnyxCollectionInputValue, OnyxInput, OnyxSetInput, OnyxMultiSetInput, OnyxMergeInput, OnyxMergeCollectionInput, OnyxSetCollectionInput, OnyxMethod, OnyxMethodMap, OnyxUpdate, OnyxValue, Selector, SetOptions, MultiMergeReplaceNullPatches, MixedOperationsQueue, };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-onyx",
-  "version": "3.0.9",
+  "version": "3.0.11",
   "author": "Expensify, Inc.",
   "homepage": "https://expensify.com",
   "description": "State management for React Native",
@@ -32,6 +32,7 @@
     "lint": "eslint .",
     "typecheck": "tsc --noEmit",
     "test": "jest",
+    "test:types": "npm run build && tsc --noEmit --project tsconfig.test.json",
     "perf-test": "npx reassure",
     "build": "tsc -p tsconfig.build.json",
     "build:watch": "nodemon --watch lib --ext js,json,ts,tsx --exec \"npm run build && npm pack\"",