react-native-onyx 1.0.131 → 2.0.1

package/{lib → dist}/storage/__mocks__/index.js

@@ -1,36 +1,36 @@
-import _ from 'underscore';
-import utils from '../../utils';
-
+"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"));
+const utils_1 = __importDefault(require("../../utils"));
 let storageMapInternal = {};
-
 const set = jest.fn((key, value) => {
     storageMapInternal[key] = value;
     return Promise.resolve(value);
 });
-
 const idbKeyvalMock = {
     setItem(key, value) {
         return set(key, value);
     },
     multiSet(pairs) {
-        const setPromises = _.map(pairs, ([key, value]) => this.setItem(key, value));
+        const setPromises = underscore_1.default.map(pairs, ([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 = _.map(keys, (key) => new Promise((resolve) => this.getItem(key).then((value) => resolve([key, value]))));
+        const getPromises = underscore_1.default.map(keys, (key) => new Promise((resolve) => this.getItem(key).then((value) => resolve([key, value]))));
         return Promise.all(getPromises);
     },
     multiMerge(pairs) {
-        _.forEach(pairs, ([key, value]) => {
+        underscore_1.default.forEach(pairs, ([key, value]) => {
             const existingValue = storageMapInternal[key];
-            const newValue = utils.fastMerge(existingValue, value);
-
+            const newValue = utils_1.default.fastMerge(existingValue, value);
             set(key, newValue);
         });
-
         return Promise.resolve(storageMapInternal);
     },
     mergeItem(key, _changes, modifiedData) {
@@ -41,7 +41,7 @@ const idbKeyvalMock = {
         return Promise.resolve();
     },
     removeItems(keys) {
-        _.each(keys, (key) => {
+        underscore_1.default.each(keys, (key) => {
             delete storageMapInternal[key];
         });
         return Promise.resolve();
@@ -51,15 +51,14 @@ const idbKeyvalMock = {
         return Promise.resolve();
     },
     getAllKeys() {
-        return Promise.resolve(_.keys(storageMapInternal));
+        return Promise.resolve(underscore_1.default.keys(storageMapInternal));
     },
-    config() {},
+    config() { },
     getDatabaseSize() {
-        return Promise.resolve({bytesRemaining: 0, bytesUsed: 99999});
+        return Promise.resolve({ bytesRemaining: 0, bytesUsed: 99999 });
     },
-    setMemoryOnlyKeys() {},
+    setMemoryOnlyKeys() { },
 };
-
 const idbKeyvalMockSpy = {
     idbKeyvalSet: set,
     setItem: jest.fn(idbKeyvalMock.setItem),
@@ -80,5 +79,4 @@ const idbKeyvalMockSpy = {
     getDatabaseSize: jest.fn(idbKeyvalMock.getDatabaseSize),
     setMemoryOnlyKeys: jest.fn(idbKeyvalMock.setMemoryOnlyKeys),
 };
-
-export default idbKeyvalMockSpy;
+exports.default = idbKeyvalMockSpy;

package/{lib/storage/index.web.js → dist/storage/index.d.ts}

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

package/dist/storage/index.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const WebStorage_1 = __importDefault(require("./WebStorage"));
+exports.default = WebStorage_1.default;

package/{lib/storage/index.native.js → dist/storage/index.native.d.ts}

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

package/dist/storage/index.native.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const NativeStorage_1 = __importDefault(require("./NativeStorage"));
+exports.default = NativeStorage_1.default;

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

@@ -0,0 +1,26 @@
+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/{lib → dist}/storage/providers/IDBKeyVal.js

@@ -1,17 +1,20 @@
-import {set, keys, getMany, setMany, get, clear, del, delMany, createStore, promisifyRequest} from 'idb-keyval';
-import _ from 'underscore';
-import utils from '../../utils';
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": 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 = () => {
     if (!customStoreInstance) {
-        customStoreInstance = createStore('OnyxDB', 'keyvaluepairs');
+        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
@@ -19,39 +22,33 @@ const provider = {
      * @param {*} value
      * @return {Promise<void>}
      */
-    setItem: (key, value) => set(key, value, getCustomStore()),
-
+    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) => getMany(keysParam, getCustomStore()).then((values) => _.map(values, (value, index) => [keysParam[index], 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>}
      */
-    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(_.map(pairs, ([key]) => promisifyRequest(store.get(key))));
-
-            return getValues.then((values) => {
-                const upsertMany = _.map(pairs, ([key, value], index) => {
-                    const prev = values[index];
-                    const newValue = utils.fastMerge(prev, value);
-                    return promisifyRequest(store.put(newValue, key));
-                });
-                return Promise.all(upsertMany);
+    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))));
+        return getValues.then((values) => {
+            const upsertMany = underscore_1.default.map(pairs, ([key, value], index) => {
+                const prev = values[index];
+                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
@@ -63,54 +60,45 @@ const provider = {
         // 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) => setMany(pairs, getCustomStore()),
-
+    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: () => clear(getCustomStore()),
-
+    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
-    setMemoryOnlyKeys: () => {},
-
+    setMemoryOnlyKeys: () => { },
     /**
      * Returns all keys available in storage
      * @returns {Promise<String[]>}
      */
-    getAllKeys: () => keys(getCustomStore()),
-
+    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) =>
-        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)),
-
+    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) => del(key, getCustomStore()),
-
+    removeItem: (key) => (0, idb_keyval_1.del)(key, getCustomStore()),
     /**
      * Remove given keys and their values from storage
      *
      * @param {Array} keysParam
      * @returns {Promise}
      */
-    removeItems: (keysParam) => delMany(keysParam, getCustomStore()),
-
+    removeItems: (keysParam) => (0, idb_keyval_1.delMany)(keysParam, getCustomStore()),
     /**
      * Gets the total bytes of the database file
      * @returns {Promise<number>}
@@ -119,17 +107,15 @@ const provider = {
         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,
-            }))
+            bytesUsed: value.usage,
+            bytesRemaining: value.quota - value.usage,
+        }))
             .catch((error) => {
-                throw new Error(`Unable to estimate web storage quota. Original error: ${error}`);
-            });
+            throw new Error(`Unable to estimate web storage quota. Original error: ${error}`);
+        });
     },
 };
-
-export default provider;
+exports.default = provider;

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

@@ -0,0 +1,52 @@
+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/{lib → dist}/storage/providers/SQLiteStorage.js

@@ -1,22 +1,23 @@
+"use strict";
+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
  */
-import {open} from 'react-native-quick-sqlite';
-import {getFreeDiskStorage} from 'react-native-device-info';
-import _ from 'underscore';
-
+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 DB_NAME = 'OnyxDB';
-const db = open({name: DB_NAME});
-
+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;');
-
 // All of the 3 pragmas below were suggested by SQLite team.
 // You can find more info about them here: https://www.sqlite.org/pragma.html
 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
@@ -24,7 +25,7 @@ const provider = {
      * @return {Promise<*>}
      */
     getItem(key) {
-        return db.executeAsync('SELECT record_key, valueJSON FROM keyvaluepairs WHERE record_key = ?;', [key]).then(({rows}) => {
+        return db.executeAsync('SELECT record_key, valueJSON FROM keyvaluepairs WHERE record_key = ?;', [key]).then(({ rows }) => {
             if (rows.length === 0) {
                 return null;
             }
@@ -32,22 +33,20 @@ const provider = {
             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 = _.map(keys, () => '?').join(',');
+        const placeholders = underscore_1.default.map(keys, () => '?').join(',');
         const command = `SELECT record_key, valueJSON FROM keyvaluepairs WHERE record_key IN (${placeholders});`;
-        return db.executeAsync(command, keys).then(({rows}) => {
+        return db.executeAsync(command, keys).then(({ rows }) => {
             // eslint-disable-next-line no-underscore-dangle
-            const result = _.map(rows._array, (row) => [row.record_key, JSON.parse(row.valueJSON)]);
+            const result = underscore_1.default.map(rows._array, (row) => [row.record_key, JSON.parse(row.valueJSON)]);
             return result;
         });
     },
-
     /**
      * Sets the value for a given key. The only requirement is that the value should be serializable to JSON string
      * @param {String} key
@@ -57,20 +56,18 @@ const provider = {
     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 = _.map(pairs, (pair) => [pair[0], JSON.stringify(_.isUndefined(pair[1]) ? null : pair[1])]);
-        if (_.isEmpty(stringifiedPairs)) {
+        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)) {
             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
@@ -84,16 +81,13 @@ const provider = {
              ON CONFLICT DO UPDATE
              SET valueJSON = JSON_PATCH(valueJSON, JSON(:value));
         `;
-
-        const nonNullishPairs = _.filter(pairs, (pair) => !_.isUndefined(pair[1]));
-        const queryArguments = _.map(nonNullishPairs, (pair) => {
+        const nonNullishPairs = underscore_1.default.filter(pairs, (pair) => !underscore_1.default.isUndefined(pair[1]));
+        const queryArguments = underscore_1.default.map(nonNullishPairs, (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
@@ -103,25 +97,21 @@ const provider = {
     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 = _.map(rows._array, (row) => row.record_key);
-            return result;
-        }),
-
+    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;
+    }),
     /**
      * 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
      *
@@ -129,28 +119,25 @@ const provider = {
      * @returns {Promise<void>}
      */
     removeItems: (keys) => {
-        const placeholders = _.map(keys, () => '?').join(',');
+        const placeholders = underscore_1.default.map(keys, () => '?').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: () => {},
-
+    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;'), getFreeDiskStorage()]).then(([pageSizeResult, pageCountResult, bytesRemaining]) => {
+        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;
             return {
@@ -159,11 +146,9 @@ const provider = {
             };
         });
     },
-
     /**
      * Noop on native
      */
-    keepInstancesSync: () => {},
+    keepInstancesSync: () => { },
 };
-
-export default provider;
+exports.default = provider;

package/{lib → dist}/utils.js

@@ -1,26 +1,25 @@
-import _ from 'underscore';
-
+"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' && _.isEmpty(a) && _.isEmpty(b);
+    return typeof a === 'object' && typeof b === 'object' && underscore_1.default.isEmpty(a) && underscore_1.default.isEmpty(b);
 }
-
 // Mostly copied from https://medium.com/@lubaka.a/how-to-remove-lodash-performance-improvement-b306669ad0e1
-
 /**
  * @param {mixed} val
  * @returns {boolean}
  */
 function isMergeableObject(val) {
     const nonNullObject = val != null ? typeof val === 'object' : false;
-    return (
-        nonNullObject &&
+    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)
-    );
+        !Array.isArray(val));
 }
-
 /**
  * @param {Object} target
  * @param {Object} source
@@ -35,46 +34,38 @@ function mergeObject(target, source, shouldRemoveNullObjectValues = true) {
         const targetKeys = Object.keys(target);
         for (let i = 0; i < targetKeys.length; ++i) {
             const key = targetKeys[i];
-
             // If shouldRemoveNullObjectValues is true, we want to remove null values from the merged object
             const isSourceOrTargetNull = target[key] === null || source[key] === null;
             const shouldOmitSourceKey = shouldRemoveNullObjectValues && isSourceOrTargetNull;
-
             if (!shouldOmitSourceKey) {
                 destination[key] = target[key];
             }
         }
     }
-
     // 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];
-
         // If shouldRemoveNullObjectValues is true, we want to remove null values from the merged object
         const shouldOmitSourceKey = shouldRemoveNullObjectValues && source[key] === null;
-
         // If we pass undefined as the updated value for a key, we want to generally ignore it
         const isSourceKeyUndefined = source[key] === 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);
                 }
-            } else if (!shouldRemoveNullObjectValues || source[key] !== null) {
+            }
+            else if (!shouldRemoveNullObjectValues || source[key] !== null) {
                 destination[key] = source[key];
             }
         }
     }
-
     return destination;
 }
-
 /**
  * Merges two objects and removes null values if "shouldRemoveNullObjectValues" is set to true
  *
@@ -91,22 +82,18 @@ 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 (_.isArray(source) || source === null || source === undefined) {
+    if (underscore_1.default.isArray(source) || source === null || source === undefined) {
         return source;
     }
     return mergeObject(target, source, shouldRemoveNullObjectValues);
 }
-
 function removeNestedNullValues(value) {
-    if (typeof value === 'object' && !_.isArray(value)) {
+    if (typeof value === 'object' && !underscore_1.default.isArray(value)) {
         return fastMerge(value, value);
     }
-
     return value;
 }
-
 function formatActionName(method, key) {
     return key ? `${method.toUpperCase()}/${key}` : method.toUpperCase();
 }
-
-export default {areObjectsEmpty, fastMerge, formatActionName, removeNestedNullValues};
+exports.default = { areObjectsEmpty, fastMerge, formatActionName, removeNestedNullValues };