react-native-onyx 2.0.4 → 2.0.5

package/dist/Onyx.js

@@ -486,7 +486,7 @@ function keysChanged(collectionKey, partialCollection, notifyRegularSubscibers =
                     const data = cachedCollection[subscriber.key];
                     const previousData = prevState[subscriber.statePropertyName];
                     // Avoids triggering unnecessary re-renders when feeding empty objects
-                    if (utils_1.default.areObjectsEmpty(data, previousData)) {
+                    if (utils_1.default.isEmptyObject(data) && utils_1.default.isEmptyObject(previousData)) {
                         return null;
                     }
                     if (data === previousData) {
@@ -601,7 +601,7 @@ function keyChanged(key, data, prevData, canUpdateSubscriber = () => true, notif
             subscriber.withOnyxInstance.setStateProxy((prevState) => {
                 const prevWithOnyxData = prevState[subscriber.statePropertyName];
                 // Avoids triggering unnecessary re-renders when feeding empty objects
-                if (utils_1.default.areObjectsEmpty(data, prevWithOnyxData)) {
+                if (utils_1.default.isEmptyObject(data) && utils_1.default.isEmptyObject(prevWithOnyxData)) {
                     return null;
                 }
                 if (prevWithOnyxData === data) {

package/dist/OnyxCache.d.ts

@@ -1,122 +1,75 @@
-export default instance;
-declare const instance: OnyxCache;
+import type { Key, Value } from './storage/providers/types';
+type StorageMap = Record<Key, Value>;
 /**
  * In memory cache providing data by reference
  * Encapsulates Onyx cache related functionality
  */
 declare class OnyxCache {
-    /**
-     * @private
-     * Cache of all the storage keys available in persistent storage
-     * @type {Set<string>}
-     */
+    /** Cache of all the storage keys available in persistent storage */
     private storageKeys;
-    /**
-     * @private
-     * Unique list of keys maintained in access order (most recent at the end)
-     * @type {Set<string>}
-     */
+    /** Unique list of keys maintained in access order (most recent at the end) */
     private recentKeys;
-    /**
-     * @private
-     * A map of cached values
-     * @type {Record<string, *>}
-     */
+    /** A map of cached values */
     private storageMap;
     /**
-     * @private
      * Captured pending tasks for already running storage methods
      * Using a map yields better performance on operations such a delete
-     * https://www.zhenghao.io/posts/object-vs-map
-     * @type {Map<string, Promise>}
      */
     private pendingPromises;
-    /**
-     * Get all the storage keys
-     * @returns {string[]}
-     */
-    getAllKeys(): string[];
+    /** Maximum size of the keys store din cache */
+    private maxRecentKeysSize;
+    constructor();
+    /** Get all the storage keys */
+    getAllKeys(): Key[];
     /**
      * Get a cached value from storage
-     * @param {string} key
-     * @param {Boolean} [shouldReindexCache] – This is an LRU cache, and by default accessing a value will make it become last in line to be evicted. This flag can be used to skip that and just access the value directly without side-effects.
-     * @returns {*}
+     * @param [shouldReindexCache] – This is an LRU cache, and by default accessing a value will make it become last in line to be evicted. This flag can be used to skip that and just access the value directly without side-effects.
      */
-    getValue(key: string, shouldReindexCache?: boolean | undefined): any;
-    /**
-     * Check whether cache has data for the given key
-     * @param {string} key
-     * @returns {boolean}
-     */
-    hasCacheForKey(key: string): boolean;
-    /**
-     * Saves a key in the storage keys list
+    getValue(key: Key, shouldReindexCache?: boolean): Value;
+    /** Check whether cache has data for the given key */
+    hasCacheForKey(key: Key): boolean;
+    /** Saves a key in the storage keys list
      * Serves to keep the result of `getAllKeys` up to date
-     * @param {string} key
      */
-    addKey(key: string): void;
+    addKey(key: Key): void;
     /**
      * Set's a key value in cache
      * Adds the key to the storage keys list as well
-     * @param {string} key
-     * @param {*} value
-     * @returns {*} value - returns the cache value
      */
-    set(key: string, value: any): any;
-    /**
-     * Forget the cached value for the given key
-     * @param {string} key
-     */
-    drop(key: string): void;
+    set(key: Key, value: Value): Value;
+    /** Forget the cached value for the given key */
+    drop(key: Key): void;
     /**
      * Deep merge data to cache, any non existing keys will be created
-     * @param {Record<string, *>} data - a map of (cache) key - values
+     * @param data - a map of (cache) key - values
      */
-    merge(data: Record<string, any>): void;
+    merge(data: StorageMap): void;
     /**
      * Check whether the given task is already running
-     * @param {string} taskName - unique name given for the task
-     * @returns {*}
+     * @param taskName - unique name given for the task
      */
-    hasPendingTask(taskName: string): any;
+    hasPendingTask(taskName: string): boolean;
     /**
      * Use this method to prevent concurrent calls for the same thing
      * Instead of calling the same task again use the existing promise
      * provided from this function
-     * @template T
-     * @param {string} taskName - unique name given for the task
-     * @returns {Promise<T>}
+     * @param taskName - unique name given for the task
      */
-    getTaskPromise<T>(taskName: string): Promise<T>;
+    getTaskPromise(taskName: string): Promise<unknown> | undefined;
     /**
      * Capture a promise for a given task so other caller can
      * hook up to the promise if it's still pending
-     * @template T
-     * @param {string} taskName - unique name for the task
-     * @param {Promise<T>} promise
-     * @returns {Promise<T>}
-     */
-    captureTask<T_1>(taskName: string, promise: Promise<T_1>): Promise<T_1>;
-    /**
-     * @private
-     * Adds a key to the top of the recently accessed keys
-     * @param {string} key
+     * @param taskName - unique name for the task
      */
+    captureTask(taskName: string, promise: Promise<unknown>): Promise<unknown>;
+    /** Adds a key to the top of the recently accessed keys */
     private addToAccessedKeys;
-    /**
-     * Remove keys that don't fall into the range of recently used keys
-     */
+    /** Remove keys that don't fall into the range of recently used keys */
     removeLeastRecentlyUsedKeys(): void;
-    /**
-     * Set the recent keys list size
-     * @param {number} limit
-     */
+    /** Set the recent keys list size */
     setRecentKeysLimit(limit: number): void;
-    maxRecentKeysSize: number | undefined;
-    /**
-     * @param {String} key
-     * @param {*} value
-     * @returns {Boolean}
-     */
-    hasValueChanged(key: string, value: any): boolean;
+    /** Check if the value has changed */
+    hasValueChanged(key: Key, value: Value): boolean;
 }
+declare const instance: OnyxCache;
+export default instance;

package/dist/OnyxCache.js

@@ -3,57 +3,31 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const underscore_1 = __importDefault(require("underscore"));
 const fast_equals_1 = require("fast-equals");
+const bindAll_1 = __importDefault(require("lodash/bindAll"));
 const utils_1 = __importDefault(require("./utils"));
-const isDefined = underscore_1.default.negate(underscore_1.default.isUndefined);
 /**
  * In memory cache providing data by reference
  * Encapsulates Onyx cache related functionality
  */
 class OnyxCache {
     constructor() {
-        /**
-         * @private
-         * Cache of all the storage keys available in persistent storage
-         * @type {Set<string>}
-         */
+        /** Maximum size of the keys store din cache */
+        this.maxRecentKeysSize = 0;
         this.storageKeys = new Set();
-        /**
-         * @private
-         * Unique list of keys maintained in access order (most recent at the end)
-         * @type {Set<string>}
-         */
         this.recentKeys = new Set();
-        /**
-         * @private
-         * A map of cached values
-         * @type {Record<string, *>}
-         */
         this.storageMap = {};
-        /**
-         * @private
-         * Captured pending tasks for already running storage methods
-         * Using a map yields better performance on operations such a delete
-         * https://www.zhenghao.io/posts/object-vs-map
-         * @type {Map<string, Promise>}
-         */
         this.pendingPromises = new Map();
         // bind all public methods to prevent problems with `this`
-        underscore_1.default.bindAll(this, 'getAllKeys', 'getValue', 'hasCacheForKey', 'addKey', 'set', 'drop', 'merge', 'hasPendingTask', 'getTaskPromise', 'captureTask', 'removeLeastRecentlyUsedKeys', 'setRecentKeysLimit');
+        (0, bindAll_1.default)(this, 'getAllKeys', 'getValue', 'hasCacheForKey', 'addKey', 'set', 'drop', 'merge', 'hasPendingTask', 'getTaskPromise', 'captureTask', 'removeLeastRecentlyUsedKeys', 'setRecentKeysLimit');
     }
-    /**
-     * Get all the storage keys
-     * @returns {string[]}
-     */
+    /** Get all the storage keys */
     getAllKeys() {
         return Array.from(this.storageKeys);
     }
     /**
      * Get a cached value from storage
-     * @param {string} key
-     * @param {Boolean} [shouldReindexCache] – This is an LRU cache, and by default accessing a value will make it become last in line to be evicted. This flag can be used to skip that and just access the value directly without side-effects.
-     * @returns {*}
+     * @param [shouldReindexCache] – This is an LRU cache, and by default accessing a value will make it become last in line to be evicted. This flag can be used to skip that and just access the value directly without side-effects.
      */
     getValue(key, shouldReindexCache = true) {
         if (shouldReindexCache) {
@@ -61,18 +35,12 @@ class OnyxCache {
         }
         return this.storageMap[key];
     }
-    /**
-     * Check whether cache has data for the given key
-     * @param {string} key
-     * @returns {boolean}
-     */
+    /** Check whether cache has data for the given key */
     hasCacheForKey(key) {
-        return isDefined(this.storageMap[key]);
+        return this.storageMap[key] !== undefined;
     }
-    /**
-     * Saves a key in the storage keys list
+    /** Saves a key in the storage keys list
      * Serves to keep the result of `getAllKeys` up to date
-     * @param {string} key
      */
     addKey(key) {
         this.storageKeys.add(key);
@@ -80,9 +48,6 @@ class OnyxCache {
     /**
      * Set's a key value in cache
      * Adds the key to the storage keys list as well
-     * @param {string} key
-     * @param {*} value
-     * @returns {*} value - returns the cache value
      */
     set(key, value) {
         this.addKey(key);
@@ -90,10 +55,7 @@ class OnyxCache {
         this.storageMap[key] = value;
         return value;
     }
-    /**
-     * Forget the cached value for the given key
-     * @param {string} key
-     */
+    /** Forget the cached value for the given key */
     drop(key) {
         delete this.storageMap[key];
         this.storageKeys.delete(key);
@@ -101,35 +63,30 @@ class OnyxCache {
     }
     /**
      * Deep merge data to cache, any non existing keys will be created
-     * @param {Record<string, *>} data - a map of (cache) key - values
+     * @param data - a map of (cache) key - values
      */
     merge(data) {
-        if (!underscore_1.default.isObject(data) || underscore_1.default.isArray(data)) {
+        if (typeof data !== 'object' || Array.isArray(data)) {
             throw new Error('data passed to cache.merge() must be an Object of onyx key/value pairs');
         }
-        // lodash adds a small overhead so we don't use it here
-        // eslint-disable-next-line prefer-object-spread, rulesdir/prefer-underscore-method
         this.storageMap = Object.assign({}, utils_1.default.fastMerge(this.storageMap, data, false));
         const storageKeys = this.getAllKeys();
-        const mergedKeys = underscore_1.default.keys(data);
+        const mergedKeys = Object.keys(data);
         this.storageKeys = new Set([...storageKeys, ...mergedKeys]);
-        underscore_1.default.each(mergedKeys, (key) => this.addToAccessedKeys(key));
+        mergedKeys.forEach((key) => this.addToAccessedKeys(key));
     }
     /**
      * Check whether the given task is already running
-     * @param {string} taskName - unique name given for the task
-     * @returns {*}
+     * @param taskName - unique name given for the task
      */
     hasPendingTask(taskName) {
-        return isDefined(this.pendingPromises.get(taskName));
+        return this.pendingPromises.get(taskName) !== undefined;
     }
     /**
      * Use this method to prevent concurrent calls for the same thing
      * Instead of calling the same task again use the existing promise
      * provided from this function
-     * @template T
-     * @param {string} taskName - unique name given for the task
-     * @returns {Promise<T>}
+     * @param taskName - unique name given for the task
      */
     getTaskPromise(taskName) {
         return this.pendingPromises.get(taskName);
@@ -137,10 +94,7 @@ class OnyxCache {
     /**
      * Capture a promise for a given task so other caller can
      * hook up to the promise if it's still pending
-     * @template T
-     * @param {string} taskName - unique name for the task
-     * @param {Promise<T>} promise
-     * @returns {Promise<T>}
+     * @param taskName - unique name for the task
      */
     captureTask(taskName, promise) {
         const returnPromise = promise.finally(() => {
@@ -149,19 +103,12 @@ class OnyxCache {
         this.pendingPromises.set(taskName, returnPromise);
         return returnPromise;
     }
-    /**
-     * @private
-     * Adds a key to the top of the recently accessed keys
-     * @param {string} key
-     */
+    /** Adds a key to the top of the recently accessed keys */
     addToAccessedKeys(key) {
-        // Removing and re-adding a key ensures it's at the end of the list
         this.recentKeys.delete(key);
         this.recentKeys.add(key);
     }
-    /**
-     * Remove keys that don't fall into the range of recently used keys
-     */
+    /** Remove keys that don't fall into the range of recently used keys */
     removeLeastRecentlyUsedKeys() {
         let numKeysToRemove = this.recentKeys.size - this.maxRecentKeysSize;
         if (numKeysToRemove <= 0) {
@@ -174,23 +121,17 @@ class OnyxCache {
             temp.push(value);
             numKeysToRemove--;
         }
+        // eslint-disable-next-line @typescript-eslint/prefer-for-of
         for (let i = 0; i < temp.length; ++i) {
             delete this.storageMap[temp[i]];
             this.recentKeys.delete(temp[i]);
         }
     }
-    /**
-     * Set the recent keys list size
-     * @param {number} limit
-     */
+    /** Set the recent keys list size */
     setRecentKeysLimit(limit) {
         this.maxRecentKeysSize = limit;
     }
-    /**
-     * @param {String} key
-     * @param {*} value
-     * @returns {Boolean}
-     */
+    /** Check if the value has changed */
     hasValueChanged(key, value) {
         return !(0, fast_equals_1.deepEqual)(this.storageMap[key], value);
     }

package/dist/storage/NativeStorage.d.ts

@@ -1,2 +1,2 @@
-export default SQLiteStorage;
 import SQLiteStorage from './providers/SQLiteStorage';
+export default SQLiteStorage;

package/dist/storage/WebStorage.d.ts

@@ -1,19 +1,3 @@
+import type StorageProvider from './providers/types';
+declare const webStorage: StorageProvider;
 export default webStorage;
-declare const webStorage: {
-    /**
-     * @param {Function} onStorageKeyChanged Storage synchronization mechanism keeping all opened tabs in sync
-     */
-    keepInstancesSync(onStorageKeyChanged: Function): void;
-    setItem: (key: string, value: any) => Promise<void>;
-    multiGet: (keysParam: string[]) => Promise<[key, value][]>;
-    multiMerge: (pairs: [key, value][]) => Promise<void>;
-    mergeItem(key: string, _changes: any, modifiedData: any): Promise<void>;
-    multiSet: (pairs: [key, value][]) => Promise<void>;
-    clear: () => Promise<void>;
-    setMemoryOnlyKeys: () => void;
-    getAllKeys: () => Promise<string[]>;
-    getItem: (key: string) => Promise<any>;
-    removeItem: (key: string) => Promise<void>;
-    removeItems: (keysParam: any[]) => Promise<any>;
-    getDatabaseSize(): Promise<number>;
-};

package/dist/storage/WebStorage.js

@@ -8,25 +8,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * when using LocalStorage APIs in the browser. These events are great because multiple tabs can listen for when
  * data changes and then stay up-to-date with everything happening in Onyx.
  */
-const underscore_1 = __importDefault(require("underscore"));
 const IDBKeyVal_1 = __importDefault(require("./providers/IDBKeyVal"));
 const SYNC_ONYX = 'SYNC_ONYX';
 /**
  * Raise an event thorough `localStorage` to let other tabs know a value changed
- * @param {String} onyxKey
  */
 function raiseStorageSyncEvent(onyxKey) {
     global.localStorage.setItem(SYNC_ONYX, onyxKey);
-    global.localStorage.removeItem(SYNC_ONYX, onyxKey);
+    global.localStorage.removeItem(SYNC_ONYX);
 }
 function raiseStorageSyncManyKeysEvent(onyxKeys) {
-    underscore_1.default.each(onyxKeys, (onyxKey) => {
+    onyxKeys.forEach((onyxKey) => {
         raiseStorageSyncEvent(onyxKey);
     });
 }
 const webStorage = Object.assign(Object.assign({}, IDBKeyVal_1.default), { 
     /**
-     * @param {Function} onStorageKeyChanged Storage synchronization mechanism keeping all opened tabs in sync
+     * @param onStorageKeyChanged Storage synchronization mechanism keeping all opened tabs in sync
      */
     keepInstancesSync(onStorageKeyChanged) {
         // Override set, remove and clear to raise storage events that we intercept in other tabs
@@ -48,7 +46,7 @@ const webStorage = Object.assign(Object.assign({}, IDBKeyVal_1.default), {
                 .then(() => {
                 // Now that storage is cleared, the storage sync event can happen which is a more atomic action
                 // for other browser tabs
-                underscore_1.default.each(allKeys, raiseStorageSyncEvent);
+                allKeys.forEach(raiseStorageSyncEvent);
             });
         };
         // This listener will only be triggered by events coming from other tabs

package/dist/storage/__mocks__/index.d.ts

@@ -1,23 +1,23 @@
-export default idbKeyvalMockSpy;
-declare namespace idbKeyvalMockSpy {
-    export { set as idbKeyvalSet };
-    export let setItem: jest.Mock<Promise<any>, [key?: any, value?: any]>;
-    export let getItem: jest.Mock<Promise<any>, [key?: any]>;
-    export let removeItem: jest.Mock<Promise<void>, [key?: any]>;
-    export let removeItems: jest.Mock<Promise<void>, [keys?: any]>;
-    export let clear: jest.Mock<Promise<void>, []>;
-    export let getAllKeys: jest.Mock<Promise<any>, []>;
-    export let config: jest.Mock<void, []>;
-    export let multiGet: jest.Mock<Promise<any>, [keys?: any]>;
-    export let multiSet: jest.Mock<Promise<any>, [pairs?: any]>;
-    export let multiMerge: jest.Mock<Promise<{}>, [pairs?: any]>;
-    export let mergeItem: jest.Mock<Promise<any>, [key?: any, _changes?: any, modifiedData?: any]>;
-    export let getStorageMap: jest.Mock<{}, []>;
-    export let setInitialMockData: jest.Mock<void, [data?: any]>;
-    export let getDatabaseSize: jest.Mock<Promise<{
-        bytesRemaining: number;
+/// <reference types="jest" />
+import type { KeyValuePairList } from '../providers/types';
+declare const idbKeyvalMockSpy: {
+    idbKeyvalSet: jest.Mock<Promise<any>, [key: any, value: any]>;
+    setItem: jest.Mock<Promise<void | import("react-native-quick-sqlite").QueryResult>, [key: string, value: IDBValidKey]>;
+    getItem: jest.Mock<Promise<IDBValidKey | null>, [key: string]>;
+    removeItem: jest.Mock<Promise<void | import("react-native-quick-sqlite").QueryResult>, [key: string]>;
+    removeItems: jest.Mock<Promise<void | import("react-native-quick-sqlite").QueryResult>, [keys: import("../providers/types").KeyList]>;
+    clear: jest.Mock<Promise<void | import("react-native-quick-sqlite").QueryResult>, []>;
+    getAllKeys: jest.Mock<Promise<import("../providers/types").KeyList>, []>;
+    multiGet: jest.Mock<Promise<KeyValuePairList>, [keys: import("../providers/types").KeyList]>;
+    multiSet: jest.Mock<Promise<void | import("react-native-quick-sqlite").BatchQueryResult>, [pairs: KeyValuePairList]>;
+    multiMerge: jest.Mock<Promise<import("react-native-quick-sqlite").BatchQueryResult | IDBValidKey[]>, [pairs: KeyValuePairList]>;
+    mergeItem: jest.Mock<Promise<void | import("react-native-quick-sqlite").BatchQueryResult>, [key: string, changes: IDBValidKey, modifiedData: IDBValidKey]>;
+    getStorageMap: jest.Mock<Record<string, IDBValidKey>, []>;
+    setInitialMockData: jest.Mock<void, [data: any]>;
+    getDatabaseSize: jest.Mock<Promise<{
         bytesUsed: number;
+        bytesRemaining: number;
     }>, []>;
-    export let setMemoryOnlyKeys: jest.Mock<void, []>;
-}
-declare const set: jest.Mock<Promise<any>, [key?: any, value?: any]>;
+    setMemoryOnlyKeys: jest.Mock<void, []>;
+};
+export default idbKeyvalMockSpy;

package/dist/storage/__mocks__/index.js

@@ -3,7 +3,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const underscore_1 = __importDefault(require("underscore"));
 const utils_1 = __importDefault(require("../../utils"));
 let storageMapInternal = {};
 const set = jest.fn((key, value) => {
@@ -15,19 +14,20 @@ const idbKeyvalMock = {
         return set(key, value);
     },
     multiSet(pairs) {
-        const setPromises = underscore_1.default.map(pairs, ([key, value]) => this.setItem(key, value));
+        const setPromises = pairs.map(([key, value]) => this.setItem(key, value));
         return new Promise((resolve) => Promise.all(setPromises).then(() => resolve(storageMapInternal)));
     },
     getItem(key) {
         return Promise.resolve(storageMapInternal[key]);
     },
     multiGet(keys) {
-        const getPromises = underscore_1.default.map(keys, (key) => new Promise((resolve) => this.getItem(key).then((value) => resolve([key, value]))));
+        const getPromises = keys.map((key) => new Promise((resolve) => this.getItem(key).then((value) => resolve([key, value]))));
         return Promise.all(getPromises);
     },
     multiMerge(pairs) {
-        underscore_1.default.forEach(pairs, ([key, value]) => {
+        pairs.forEach(([key, value]) => {
             const existingValue = storageMapInternal[key];
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             const newValue = utils_1.default.fastMerge(existingValue, value);
             set(key, newValue);
         });
@@ -41,7 +41,7 @@ const idbKeyvalMock = {
         return Promise.resolve();
     },
     removeItems(keys) {
-        underscore_1.default.each(keys, (key) => {
+        keys.forEach((key) => {
             delete storageMapInternal[key];
         });
         return Promise.resolve();
@@ -51,12 +51,12 @@ const idbKeyvalMock = {
         return Promise.resolve();
     },
     getAllKeys() {
-        return Promise.resolve(underscore_1.default.keys(storageMapInternal));
+        return Promise.resolve(Object.keys(storageMapInternal));
     },
-    config() { },
     getDatabaseSize() {
         return Promise.resolve({ bytesRemaining: 0, bytesUsed: 99999 });
     },
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
     setMemoryOnlyKeys() { },
 };
 const idbKeyvalMockSpy = {
@@ -67,7 +67,6 @@ const idbKeyvalMockSpy = {
     removeItems: jest.fn(idbKeyvalMock.removeItems),
     clear: jest.fn(idbKeyvalMock.clear),
     getAllKeys: jest.fn(idbKeyvalMock.getAllKeys),
-    config: jest.fn(idbKeyvalMock.config),
     multiGet: jest.fn(idbKeyvalMock.multiGet),
     multiSet: jest.fn(idbKeyvalMock.multiSet),
     multiMerge: jest.fn(idbKeyvalMock.multiMerge),

package/dist/storage/index.d.ts

@@ -1,2 +1,2 @@
-export default WebStorage;
 import WebStorage from './WebStorage';
+export default WebStorage;

package/dist/storage/index.native.d.ts

@@ -1,2 +1,2 @@
-export default NativeStorage;
 import NativeStorage from './NativeStorage';
+export default NativeStorage;

package/dist/storage/providers/IDBKeyVal.d.ts

@@ -1,26 +1,3 @@
+import type StorageProvider from './types';
+declare const provider: StorageProvider;
 export default provider;
-declare namespace provider {
-    function setItem(key: string, value: any): Promise<void>;
-    function multiGet(keysParam: string[]): Promise<[key, value][]>;
-    function multiMerge(pairs: [key, value][]): Promise<void>;
-    /**
-     * Merging an existing value with a new one
-     * @param {String} key
-     * @param {any} _changes - not used, as we rely on the pre-merged data from the `modifiedData`
-     * @param {any} modifiedData - the pre-merged data from `Onyx.applyMerge`
-     * @return {Promise<void>}
-     */
-    function mergeItem(key: string, _changes: any, modifiedData: any): Promise<void>;
-    function multiSet(pairs: [key, value][]): Promise<void>;
-    function clear(): Promise<void>;
-    function setMemoryOnlyKeys(): void;
-    function getAllKeys(): Promise<string[]>;
-    function getItem(key: string): Promise<any>;
-    function removeItem(key: string): Promise<void>;
-    function removeItems(keysParam: any[]): Promise<any>;
-    /**
-     * Gets the total bytes of the database file
-     * @returns {Promise<number>}
-     */
-    function getDatabaseSize(): Promise<number>;
-}

package/dist/storage/providers/IDBKeyVal.js

@@ -4,115 +4,60 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const idb_keyval_1 = require("idb-keyval");
-const underscore_1 = __importDefault(require("underscore"));
 const utils_1 = __importDefault(require("../../utils"));
 // We don't want to initialize the store while the JS bundle loads as idb-keyval will try to use global.indexedDB
 // which might not be available in certain environments that load the bundle (e.g. electron main process).
 let customStoreInstance;
-const getCustomStore = () => {
+function getCustomStore() {
     if (!customStoreInstance) {
         customStoreInstance = (0, idb_keyval_1.createStore)('OnyxDB', 'keyvaluepairs');
     }
     return customStoreInstance;
-};
+}
 const provider = {
-    /**
-     * Sets the value for a given key. The only requirement is that the value should be serializable to JSON string
-     * @param {String} key
-     * @param {*} value
-     * @return {Promise<void>}
-     */
     setItem: (key, value) => (0, idb_keyval_1.set)(key, value, getCustomStore()),
-    /**
-     * Get multiple key-value pairs for the give array of keys in a batch.
-     * This is optimized to use only one database transaction.
-     * @param {String[]} keysParam
-     * @return {Promise<Array<[key, value]>>}
-     */
-    multiGet: (keysParam) => (0, idb_keyval_1.getMany)(keysParam, getCustomStore()).then((values) => underscore_1.default.map(values, (value, index) => [keysParam[index], value])),
-    /**
-     * Multiple merging of existing and new values in a batch
-     * @param {Array<[key, value]>} pairs
-     * This function also removes all nested null values from an object.
-     * @return {Promise<void>}
-     */
+    multiGet: (keysParam) => (0, idb_keyval_1.getMany)(keysParam, getCustomStore()).then((values) => values.map((value, index) => [keysParam[index], value])),
     multiMerge: (pairs) => getCustomStore()('readwrite', (store) => {
         // Note: we are using the manual store transaction here, to fit the read and update
         // of the items in one transaction to achieve best performance.
-        const getValues = Promise.all(underscore_1.default.map(pairs, ([key]) => (0, idb_keyval_1.promisifyRequest)(store.get(key))));
+        const getValues = Promise.all(pairs.map(([key]) => (0, idb_keyval_1.promisifyRequest)(store.get(key))));
         return getValues.then((values) => {
-            const upsertMany = underscore_1.default.map(pairs, ([key, value], index) => {
+            const upsertMany = pairs.map(([key, value], index) => {
                 const prev = values[index];
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 const newValue = utils_1.default.fastMerge(prev, value);
                 return (0, idb_keyval_1.promisifyRequest)(store.put(newValue, key));
             });
             return Promise.all(upsertMany);
         });
     }),
-    /**
-     * Merging an existing value with a new one
-     * @param {String} key
-     * @param {any} _changes - not used, as we rely on the pre-merged data from the `modifiedData`
-     * @param {any} modifiedData - the pre-merged data from `Onyx.applyMerge`
-     * @return {Promise<void>}
-     */
     mergeItem(key, _changes, modifiedData) {
         // Since Onyx also merged the existing value with the changes, we can just set the value directly
         return provider.setItem(key, modifiedData);
     },
-    /**
-     * Stores multiple key-value pairs in a batch
-     * @param {Array<[key, value]>} pairs
-     * @return {Promise<void>}
-     */
     multiSet: (pairs) => (0, idb_keyval_1.setMany)(pairs, getCustomStore()),
-    /**
-     * Clear everything from storage and also stops the SyncQueue from adding anything more to storage
-     * @returns {Promise<void>}
-     */
     clear: () => (0, idb_keyval_1.clear)(getCustomStore()),
-    // This is a noop for now in order to keep clients from crashing see https://github.com/Expensify/Expensify/issues/312438
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
     setMemoryOnlyKeys: () => { },
-    /**
-     * Returns all keys available in storage
-     * @returns {Promise<String[]>}
-     */
     getAllKeys: () => (0, idb_keyval_1.keys)(getCustomStore()),
-    /**
-     * Get the value of a given key or return `null` if it's not available in storage
-     * @param {String} key
-     * @return {Promise<*>}
-     */
     getItem: (key) => (0, idb_keyval_1.get)(key, getCustomStore())
         // idb-keyval returns undefined for missing items, but this needs to return null so that idb-keyval does the same thing as SQLiteStorage.
         .then((val) => (val === undefined ? null : val)),
-    /**
-     * Remove given key and it's value from storage
-     * @param {String} key
-     * @returns {Promise<void>}
-     */
     removeItem: (key) => (0, idb_keyval_1.del)(key, getCustomStore()),
-    /**
-     * Remove given keys and their values from storage
-     *
-     * @param {Array} keysParam
-     * @returns {Promise}
-     */
     removeItems: (keysParam) => (0, idb_keyval_1.delMany)(keysParam, getCustomStore()),
-    /**
-     * Gets the total bytes of the database file
-     * @returns {Promise<number>}
-     */
     getDatabaseSize() {
         if (!window.navigator || !window.navigator.storage) {
             throw new Error('StorageManager browser API unavailable');
         }
         return window.navigator.storage
             .estimate()
-            .then((value) => ({
-            bytesUsed: value.usage,
-            bytesRemaining: value.quota - value.usage,
-        }))
+            .then((value) => {
+            var _a, _b, _c;
+            return ({
+                bytesUsed: (_a = value.usage) !== null && _a !== void 0 ? _a : 0,
+                bytesRemaining: ((_b = value.quota) !== null && _b !== void 0 ? _b : 0) - ((_c = value.usage) !== null && _c !== void 0 ? _c : 0),
+            });
+        })
             .catch((error) => {
             throw new Error(`Unable to estimate web storage quota. Original error: ${error}`);
         });

package/dist/storage/providers/SQLiteStorage.d.ts

@@ -1,52 +1,3 @@
+import type StorageProvider from './types';
+declare const provider: StorageProvider;
 export default provider;
-declare namespace provider {
-    /**
-     * Get the value of a given key or return `null` if it's not available in storage
-     * @param {String} key
-     * @return {Promise<*>}
-     */
-    function getItem(key: string): Promise<any>;
-    /**
-     * Get multiple key-value pairs for the given array of keys in a batch
-     * @param {String[]} keys
-     * @return {Promise<Array<[key, value]>>}
-     */
-    function multiGet(keys: string[]): Promise<[key, value][]>;
-    /**
-     * Sets the value for a given key. The only requirement is that the value should be serializable to JSON string
-     * @param {String} key
-     * @param {*} value
-     * @return {Promise<void>}
-     */
-    function setItem(key: string, value: any): Promise<void>;
-    /**
-     * Stores multiple key-value pairs in a batch
-     * @param {Array<[key, value]>} pairs
-     * @return {Promise<void>}
-     */
-    function multiSet(pairs: [key, value][]): Promise<void>;
-    /**
-     * Multiple merging of existing and new values in a batch
-     * @param {Array<[key, value]>} pairs
-     * @return {Promise<void>}
-     */
-    function multiMerge(pairs: [key, value][]): Promise<void>;
-    /**
-     * Merges an existing value with a new one by leveraging JSON_PATCH
-     * @param {String} key
-     * @param {*} changes - the delta for a specific key
-     * @return {Promise<void>}
-     */
-    function mergeItem(key: string, changes: any): Promise<void>;
-    function getAllKeys(): Promise<string[]>;
-    function removeItem(key: string): Promise<void>;
-    function removeItems(keys: string[]): Promise<void>;
-    function clear(): Promise<void>;
-    function setMemoryOnlyKeys(): void;
-    /**
-     * Gets the total bytes of the database file
-     * @returns {Promise}
-     */
-    function getDatabaseSize(): Promise<any>;
-    function keepInstancesSync(): void;
-}

package/dist/storage/providers/SQLiteStorage.js

@@ -3,13 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * The SQLiteStorage provider stores everything in a key/value store by
- * converting the value to a JSON string
- */
 const react_native_quick_sqlite_1 = require("react-native-quick-sqlite");
 const react_native_device_info_1 = require("react-native-device-info");
-const underscore_1 = __importDefault(require("underscore"));
+const utils_1 = __importDefault(require("../../utils"));
 const DB_NAME = 'OnyxDB';
 const db = (0, react_native_quick_sqlite_1.open)({ name: DB_NAME });
 db.execute('CREATE TABLE IF NOT EXISTS keyvaluepairs (record_key TEXT NOT NULL PRIMARY KEY , valueJSON JSON NOT NULL) WITHOUT ROWID;');
@@ -19,60 +15,34 @@ db.execute('PRAGMA CACHE_SIZE=-20000;');
 db.execute('PRAGMA synchronous=NORMAL;');
 db.execute('PRAGMA journal_mode=WAL;');
 const provider = {
-    /**
-     * Get the value of a given key or return `null` if it's not available in storage
-     * @param {String} key
-     * @return {Promise<*>}
-     */
     getItem(key) {
         return db.executeAsync('SELECT record_key, valueJSON FROM keyvaluepairs WHERE record_key = ?;', [key]).then(({ rows }) => {
-            if (rows.length === 0) {
+            if (!rows || (rows === null || rows === void 0 ? void 0 : rows.length) === 0) {
                 return null;
             }
-            const result = rows.item(0);
+            const result = rows === null || rows === void 0 ? void 0 : rows.item(0);
             return JSON.parse(result.valueJSON);
         });
     },
-    /**
-     * Get multiple key-value pairs for the given array of keys in a batch
-     * @param {String[]} keys
-     * @return {Promise<Array<[key, value]>>}
-     */
     multiGet(keys) {
-        const placeholders = underscore_1.default.map(keys, () => '?').join(',');
+        const placeholders = keys.map(() => '?').join(',');
         const command = `SELECT record_key, valueJSON FROM keyvaluepairs WHERE record_key IN (${placeholders});`;
         return db.executeAsync(command, keys).then(({ rows }) => {
             // eslint-disable-next-line no-underscore-dangle
-            const result = underscore_1.default.map(rows._array, (row) => [row.record_key, JSON.parse(row.valueJSON)]);
-            return result;
+            const result = rows === null || rows === void 0 ? void 0 : rows._array.map((row) => [row.record_key, JSON.parse(row.valueJSON)]);
+            return (result !== null && result !== void 0 ? result : []);
         });
     },
-    /**
-     * Sets the value for a given key. The only requirement is that the value should be serializable to JSON string
-     * @param {String} key
-     * @param {*} value
-     * @return {Promise<void>}
-     */
     setItem(key, value) {
         return db.executeAsync('REPLACE INTO keyvaluepairs (record_key, valueJSON) VALUES (?, ?);', [key, JSON.stringify(value)]);
     },
-    /**
-     * Stores multiple key-value pairs in a batch
-     * @param {Array<[key, value]>} pairs
-     * @return {Promise<void>}
-     */
     multiSet(pairs) {
-        const stringifiedPairs = underscore_1.default.map(pairs, (pair) => [pair[0], JSON.stringify(underscore_1.default.isUndefined(pair[1]) ? null : pair[1])]);
-        if (underscore_1.default.isEmpty(stringifiedPairs)) {
+        const stringifiedPairs = pairs.map((pair) => [pair[0], JSON.stringify(pair[1] === undefined ? null : pair[1])]);
+        if (utils_1.default.isEmptyObject(stringifiedPairs)) {
             return Promise.resolve();
         }
         return db.executeBatchAsync([['REPLACE INTO keyvaluepairs (record_key, valueJSON) VALUES (?, json(?));', stringifiedPairs]]);
     },
-    /**
-     * Multiple merging of existing and new values in a batch
-     * @param {Array<[key, value]>} pairs
-     * @return {Promise<void>}
-     */
     multiMerge(pairs) {
         // Note: We use `ON CONFLICT DO UPDATE` here instead of `INSERT OR REPLACE INTO`
         // so the new JSON value is merged into the old one if there's an existing value
@@ -81,74 +51,42 @@ const provider = {
              ON CONFLICT DO UPDATE
              SET valueJSON = JSON_PATCH(valueJSON, JSON(:value));
         `;
-        const nonNullishPairs = underscore_1.default.filter(pairs, (pair) => !underscore_1.default.isUndefined(pair[1]));
-        const queryArguments = underscore_1.default.map(nonNullishPairs, (pair) => {
+        const nonNullishPairs = pairs.filter((pair) => pair[1] !== undefined);
+        const queryArguments = nonNullishPairs.map((pair) => {
             const value = JSON.stringify(pair[1]);
             return [pair[0], value];
         });
         return db.executeBatchAsync([[query, queryArguments]]);
     },
-    /**
-     * Merges an existing value with a new one by leveraging JSON_PATCH
-     * @param {String} key
-     * @param {*} changes - the delta for a specific key
-     * @return {Promise<void>}
-     */
     mergeItem(key, changes) {
         return this.multiMerge([[key, changes]]);
     },
-    /**
-     * Returns all keys available in storage
-     * @returns {Promise<String[]>}
-     */
     getAllKeys: () => db.executeAsync('SELECT record_key FROM keyvaluepairs;').then(({ rows }) => {
         // eslint-disable-next-line no-underscore-dangle
-        const result = underscore_1.default.map(rows._array, (row) => row.record_key);
-        return result;
+        const result = rows === null || rows === void 0 ? void 0 : rows._array.map((row) => row.record_key);
+        return (result !== null && result !== void 0 ? result : []);
     }),
-    /**
-     * Removes given key and it's value from storage
-     * @param {String} key
-     * @returns {Promise<void>}
-     */
     removeItem: (key) => db.executeAsync('DELETE FROM keyvaluepairs WHERE record_key = ?;', [key]),
-    /**
-     * Removes given keys and their values from storage
-     *
-     * @param {Array<String>} keys
-     * @returns {Promise<void>}
-     */
     removeItems: (keys) => {
-        const placeholders = underscore_1.default.map(keys, () => '?').join(',');
+        const placeholders = keys.map(() => '?').join(',');
         const query = `DELETE FROM keyvaluepairs WHERE record_key IN (${placeholders});`;
         return db.executeAsync(query, keys);
     },
-    /**
-     * Clears absolutely everything from storage
-     * @returns {Promise<void>}
-     */
     clear: () => db.executeAsync('DELETE FROM keyvaluepairs;', []),
-    /**
-     * Noop on mobile for now.
-     */
-    setMemoryOnlyKeys: () => { },
-    /**
-     * Gets the total bytes of the database file
-     * @returns {Promise}
-     */
     getDatabaseSize() {
         return Promise.all([db.executeAsync('PRAGMA page_size;'), db.executeAsync('PRAGMA page_count;'), (0, react_native_device_info_1.getFreeDiskStorage)()]).then(([pageSizeResult, pageCountResult, bytesRemaining]) => {
-            const pageSize = pageSizeResult.rows.item(0).page_size;
-            const pageCount = pageCountResult.rows.item(0).page_count;
+            var _a, _b;
+            const pageSize = (_a = pageSizeResult.rows) === null || _a === void 0 ? void 0 : _a.item(0).page_size;
+            const pageCount = (_b = pageCountResult.rows) === null || _b === void 0 ? void 0 : _b.item(0).page_count;
             return {
                 bytesUsed: pageSize * pageCount,
                 bytesRemaining,
             };
         });
     },
-    /**
-     * Noop on native
-     */
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    setMemoryOnlyKeys: () => { },
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
     keepInstancesSync: () => { },
 };
 exports.default = provider;

package/dist/storage/providers/types.d.ts

@@ -0,0 +1,68 @@
+import type { BatchQueryResult, QueryResult } from 'react-native-quick-sqlite';
+type Key = string;
+type Value = IDBValidKey;
+type KeyValuePair = [Key, Value];
+type KeyList = Key[];
+type KeyValuePairList = KeyValuePair[];
+type OnStorageKeyChanged = (key: Key, value: Value | null) => void;
+type StorageProvider = {
+    /**
+     * Gets the value of a given key or return `null` if it's not available in storage
+     */
+    getItem: (key: Key) => Promise<Value | null>;
+    /**
+     * Get multiple key-value pairs for the given array of keys in a batch
+     */
+    multiGet: (keys: KeyList) => Promise<KeyValuePairList>;
+    /**
+     * Sets the value for a given key. The only requirement is that the value should be serializable to JSON string
+     */
+    setItem: (key: Key, value: Value) => Promise<QueryResult | void>;
+    /**
+     * Stores multiple key-value pairs in a batch
+     */
+    multiSet: (pairs: KeyValuePairList) => Promise<BatchQueryResult | void>;
+    /**
+     * Multiple merging of existing and new values in a batch
+     */
+    multiMerge: (pairs: KeyValuePairList) => Promise<BatchQueryResult | IDBValidKey[]>;
+    /**
+     * Merges an existing value with a new one by leveraging JSON_PATCH
+     * @param changes - the delta for a specific key
+     * @param modifiedData - the pre-merged data from `Onyx.applyMerge`
+     */
+    mergeItem: (key: Key, changes: Value, modifiedData: Value) => Promise<BatchQueryResult | void>;
+    /**
+     * Returns all keys available in storage
+     */
+    getAllKeys: () => Promise<KeyList>;
+    /**
+     * Removes given key and its value from storage
+     */
+    removeItem: (key: Key) => Promise<QueryResult | void>;
+    /**
+     * Removes given keys and their values from storage
+     */
+    removeItems: (keys: KeyList) => Promise<QueryResult | void>;
+    /**
+     * Clears absolutely everything from storage
+     */
+    clear: () => Promise<QueryResult | void>;
+    /**
+     * Sets memory only keys
+     */
+    setMemoryOnlyKeys: () => void;
+    /**
+     * Gets the total bytes of the database file
+     */
+    getDatabaseSize: () => Promise<{
+        bytesUsed: number;
+        bytesRemaining: number;
+    }>;
+    /**
+     * @param onStorageKeyChanged Storage synchronization mechanism keeping all opened tabs in sync
+     */
+    keepInstancesSync?: (onStorageKeyChanged: OnStorageKeyChanged) => void;
+};
+export default StorageProvider;
+export type { Value, Key, KeyList, KeyValuePairList };

package/dist/storage/providers/types.js

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

package/dist/utils.d.ts

@@ -1,5 +1,8 @@
-import {OnyxKey} from './types';
-
+import type { OnyxKey } from './types';
+type EmptyObject = Record<string, never>;
+type EmptyValue = EmptyObject | null | undefined;
+/** Checks whether the given object is an object and not null/undefined. */
+declare function isEmptyObject<T>(obj: T | EmptyValue): obj is EmptyValue;
 /**
  * Merges two objects and removes null values if "shouldRemoveNullObjectValues" is set to true
  *
@@ -7,11 +10,15 @@ import {OnyxKey} from './types';
  * On native, when merging an existing value with new changes, SQLite will use JSON_PATCH, which removes top-level nullish values.
  * To be consistent with the behaviour for merge, we'll also want to remove null values for "set" operations.
  */
-declare function fastMerge<T>(target: T, source: T, shouldRemoveNullObjectValues: boolean = true): T;
-
-/**
- * Returns a formatted action name to be send to DevTools, given the method and optionally the key that was changed
- */
+declare function fastMerge<TTarget extends unknown[] | Record<string, unknown>>(target: TTarget, source: TTarget, shouldRemoveNullObjectValues?: boolean): TTarget;
+/** Deep removes the nested null values from the given value. */
+declare function removeNestedNullValues(value: unknown[] | Record<string, unknown>): Record<string, unknown> | unknown[];
+/** Formats the action name by uppercasing and adding the key if provided. */
 declare function formatActionName(method: string, key?: OnyxKey): string;
-
-export default {fastMerge, formatActionName};
+declare const _default: {
+    isEmptyObject: typeof isEmptyObject;
+    fastMerge: typeof fastMerge;
+    formatActionName: typeof formatActionName;
+    removeNestedNullValues: typeof removeNestedNullValues;
+};
+export default _default;

package/dist/utils.js

@@ -1,66 +1,58 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const underscore_1 = __importDefault(require("underscore"));
-function areObjectsEmpty(a, b) {
-    return typeof a === 'object' && typeof b === 'object' && underscore_1.default.isEmpty(a) && underscore_1.default.isEmpty(b);
+/** Checks whether the given object is an object and not null/undefined. */
+function isEmptyObject(obj) {
+    return typeof obj === 'object' && Object.keys(obj || {}).length === 0;
 }
 // Mostly copied from https://medium.com/@lubaka.a/how-to-remove-lodash-performance-improvement-b306669ad0e1
 /**
- * @param {mixed} val
- * @returns {boolean}
+ * Checks whether the given value can be merged. It has to be an object, but not an array, RegExp or Date.
  */
-function isMergeableObject(val) {
-    const nonNullObject = val != null ? typeof val === 'object' : false;
-    return (nonNullObject &&
-        Object.prototype.toString.call(val) !== '[object RegExp]' &&
-        Object.prototype.toString.call(val) !== '[object Date]' &&
-        // eslint-disable-next-line rulesdir/prefer-underscore-method
-        !Array.isArray(val));
+function isMergeableObject(value) {
+    const nonNullObject = value != null ? typeof value === 'object' : false;
+    return nonNullObject && Object.prototype.toString.call(value) !== '[object RegExp]' && Object.prototype.toString.call(value) !== '[object Date]' && !Array.isArray(value);
 }
 /**
- * @param {Object} target
- * @param {Object} source
- * @param {Boolean} shouldRemoveNullObjectValues
- * @returns {Object}
+ * Merges the source object into the target object.
+ * @param target - The target object.
+ * @param source - The source object.
+ * @param shouldRemoveNullObjectValues - If true, null object values will be removed.
+ * @returns - The merged object.
  */
 function mergeObject(target, source, shouldRemoveNullObjectValues = true) {
     const destination = {};
     if (isMergeableObject(target)) {
         // lodash adds a small overhead so we don't use it here
-        // eslint-disable-next-line rulesdir/prefer-underscore-method
         const targetKeys = Object.keys(target);
         for (let i = 0; i < targetKeys.length; ++i) {
             const key = targetKeys[i];
+            const sourceValue = source === null || source === void 0 ? void 0 : source[key];
+            const targetValue = target === null || target === void 0 ? void 0 : target[key];
             // If shouldRemoveNullObjectValues is true, we want to remove null values from the merged object
-            const isSourceOrTargetNull = target[key] === null || source[key] === null;
+            const isSourceOrTargetNull = targetValue === null || sourceValue === null;
             const shouldOmitSourceKey = shouldRemoveNullObjectValues && isSourceOrTargetNull;
             if (!shouldOmitSourceKey) {
-                destination[key] = target[key];
+                destination[key] = targetValue;
             }
         }
     }
-    // lodash adds a small overhead so we don't use it here
-    // eslint-disable-next-line rulesdir/prefer-underscore-method
     const sourceKeys = Object.keys(source);
     for (let i = 0; i < sourceKeys.length; ++i) {
         const key = sourceKeys[i];
+        const sourceValue = source === null || source === void 0 ? void 0 : source[key];
+        const targetValue = target === null || target === void 0 ? void 0 : target[key];
         // If shouldRemoveNullObjectValues is true, we want to remove null values from the merged object
-        const shouldOmitSourceKey = shouldRemoveNullObjectValues && source[key] === null;
+        const shouldOmitSourceKey = shouldRemoveNullObjectValues && sourceValue === null;
         // If we pass undefined as the updated value for a key, we want to generally ignore it
-        const isSourceKeyUndefined = source[key] === undefined;
+        const isSourceKeyUndefined = sourceValue === undefined;
         if (!isSourceKeyUndefined && !shouldOmitSourceKey) {
-            const isSourceKeyMergable = isMergeableObject(source[key]);
-            if (isSourceKeyMergable && target[key]) {
-                if (!shouldRemoveNullObjectValues || isSourceKeyMergable) {
-                    // eslint-disable-next-line no-use-before-define
-                    destination[key] = fastMerge(target[key], source[key], shouldRemoveNullObjectValues);
-                }
+            const isSourceKeyMergable = isMergeableObject(sourceValue);
+            if (isSourceKeyMergable && targetValue) {
+                // eslint-disable-next-line no-use-before-define
+                destination[key] = fastMerge(targetValue, sourceValue, shouldRemoveNullObjectValues);
             }
-            else if (!shouldRemoveNullObjectValues || source[key] !== null) {
-                destination[key] = source[key];
+            else if (!shouldRemoveNullObjectValues || sourceValue !== null) {
+                destination[key] = sourceValue;
             }
         }
     }
@@ -72,28 +64,25 @@ function mergeObject(target, source, shouldRemoveNullObjectValues = true) {
  * 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.
  * On native, when merging an existing value with new changes, SQLite will use JSON_PATCH, which removes top-level nullish values.
  * To be consistent with the behaviour for merge, we'll also want to remove null values for "set" operations.
- *
- * @param {Object|Array} target
- * @param {Object|Array} source
- * @param {Boolean} shouldRemoveNullObjectValues
- * @returns {Object|Array}
  */
 function fastMerge(target, source, shouldRemoveNullObjectValues = true) {
     // We have to ignore arrays and nullish values here,
     // otherwise "mergeObject" will throw an error,
     // because it expects an object as "source"
-    if (underscore_1.default.isArray(source) || source === null || source === undefined) {
+    if (Array.isArray(source) || source === null || source === undefined) {
         return source;
     }
     return mergeObject(target, source, shouldRemoveNullObjectValues);
 }
+/** Deep removes the nested null values from the given value. */
 function removeNestedNullValues(value) {
-    if (typeof value === 'object' && !underscore_1.default.isArray(value)) {
+    if (typeof value === 'object' && !Array.isArray(value)) {
         return fastMerge(value, value);
     }
     return value;
 }
+/** Formats the action name by uppercasing and adding the key if provided. */
 function formatActionName(method, key) {
     return key ? `${method.toUpperCase()}/${key}` : method.toUpperCase();
 }
-exports.default = { areObjectsEmpty, fastMerge, formatActionName, removeNestedNullValues };
+exports.default = { isEmptyObject, fastMerge, formatActionName, removeNestedNullValues };

package/dist/withOnyx.js

@@ -189,7 +189,7 @@ function default_1(mapOnyxToState, shouldDelayUpdates = false) {
                 // This simply bypasses the loading check if the tempState is gone and the update can be safely queued with a normal setStateProxy.
                 if (!this.state.loading || !this.tempState) {
                     // Performance optimization, do not trigger update with same values
-                    if (prevValue === val || utils_1.default.areObjectsEmpty(prevValue, val)) {
+                    if (prevValue === val || (utils_1.default.isEmptyObject(prevValue) && utils_1.default.isEmptyObject(val))) {
                         return;
                     }
                     this.setStateProxy({ [statePropertyName]: val });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-onyx",
-  "version": "2.0.4",
+  "version": "2.0.5",
   "author": "Expensify, Inc.",
   "homepage": "https://expensify.com",
   "description": "State management for React Native",
@@ -49,10 +49,12 @@
     "@testing-library/jest-native": "^3.4.2",
     "@testing-library/react-native": "^7.0.2",
     "@types/jest": "^28.1.8",
+    "@types/lodash": "^4.14.202",
     "@types/node": "^20.11.5",
     "@types/react": "^18.2.14",
     "@types/react-dom": "^18.2.18",
     "@types/react-native": "^0.70.0",
+    "@types/underscore": "^1.11.15",
     "@typescript-eslint/eslint-plugin": "^6.19.0",
     "@typescript-eslint/parser": "^6.19.0",
     "eslint": "^8.56.0",