react-native-onyx 2.0.3 → 2.0.5

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;