Use faster implementation for merging

lib/Onyx.js

@@ -6,7 +6,7 @@ import Storage from './storage';
 import * as Logger from './Logger';
 import cache from './OnyxCache';
 import createDeferredTask from './createDeferredTask';
-import mergeWithCustomized from './mergeWithCustomized';
+import fastMerge from './fastMerge';
 
 // Keeps track of the last connectionID that was used so we can keep incrementing it
 let lastConnectionID = 0;
@@ -761,7 +761,9 @@ function applyMerge(key, data) {
     if (_.isObject(data) || _.every(mergeValues, _.isObject)) {
         // Object values are merged one after the other
         return _.reduce(mergeValues, (modifiedData, mergeValue) => {
-            const newData = mergeWithCustomized({}, modifiedData, mergeValue);
+            // lodash adds a small overhead so we don't use it here
+            // eslint-disable-next-line prefer-object-spread, rulesdir/prefer-underscore-method
+            const newData = Object.assign({}, fastMerge(modifiedData, mergeValue));
 
             // We will also delete any object keys that are undefined or null.
             // Deleting keys is not supported by AsyncStorage so we do it this way.
@@ -832,7 +834,7 @@ function initializeWithDefaultKeyStates() {
         .then((pairs) => {
             const asObject = _.object(pairs);
 
-            const merged = mergeWithCustomized(asObject, defaultKeyStates);
+            const merged = fastMerge(asObject, defaultKeyStates);
             cache.merge(merged);
             _.each(merged, (val, key) => keyChanged(key, val));
         });

lib/OnyxCache.js

@@ -1,5 +1,5 @@
 import _ from 'underscore';
-import mergeWithCustomized from './mergeWithCustomized';
+import fastMerge from './fastMerge';
 
 const isDefined = _.negate(_.isUndefined);
 
@@ -110,7 +110,9 @@ class OnyxCache {
      * @param {Record<string, *>} data - a map of (cache) key - values
      */
     merge(data) {
-        this.storageMap = mergeWithCustomized({}, this.storageMap, data);
+        // 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({}, fastMerge(this.storageMap, data));
 
         const storageKeys = this.getAllKeys();
         const mergedKeys = _.keys(data);

lib/fastMerge.js

@@ -0,0 +1,66 @@
+// 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
+    && Object.prototype.toString.call(val) !== '[object RegExp]'
+    && Object.prototype.toString.call(val) !== '[object Date]');
+}
+
+/**
+ * @param {Object} target
+ * @param {Object} source
+ * @returns {Object}
+*/
+function mergeObject(target, source) {
+    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];
+            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 (source[key] === undefined) {
+            // eslint-disable-next-line no-continue
+            continue;
+        }
+        if (!isMergeableObject(source[key]) || !target[key]) {
+            destination[key] = source[key];
+        } else {
+            // eslint-disable-next-line no-use-before-define
+            destination[key] = fastMerge(target[key], source[key]);
+        }
+    }
+
+    return destination;
+}
+
+/**
+ * @param {Object|Array} target
+ * @param {Object|Array} source
+ * @returns {Object|Array}
+*/
+function fastMerge(target, source) {
+    // lodash adds a small overhead so we don't use it here
+    // eslint-disable-next-line rulesdir/prefer-underscore-method
+    const array = Array.isArray(source);
+    if (array) {
+        return source;
+    }
+    return mergeObject(target, source);
+}
+
+export default fastMerge;

lib/storage/providers/LocalForage.js

@@ -7,7 +7,7 @@
 import localforage from 'localforage';
 import _ from 'underscore';
 import SyncQueue from '../../SyncQueue';
-import mergeWithCustomized from '../../mergeWithCustomized';
+import fastMerge from '../../fastMerge';
 
 localforage.config({
     name: 'OnyxDB',
@@ -24,7 +24,10 @@ const provider = {
             return localforage.getItem(key)
                 .then((existingValue) => {
                     const newValue = _.isObject(existingValue)
-                        ? mergeWithCustomized({}, existingValue, value)
+
+                        // lodash adds a small overhead so we don't use it here
+                        // eslint-disable-next-line prefer-object-spread, rulesdir/prefer-underscore-method
+                        ? Object.assign({}, fastMerge(existingValue, value))
                         : value;
                     return localforage.setItem(key, newValue);
                 });