deepmerge - npm Package Compare versions

Comparing version 0.2.1 to 0.2.4

index.js

 module.exports = function merge (target, src) {
-    var dst = {}
-    if (target && typeof target === 'object') {
-        Object.keys(target).forEach(function (key) {
-            dst[key] = target[key]
+    var array = Array.isArray(src)
+    var dst = array && [] || {}
+
+    if (array) {
+        target = target || []
+        dst = dst.concat(target)
+        src.forEach(function(e, i) {
+            if (typeof e === 'object') {
+                dst[i] = merge(target[i], e)
+            } else {
+                if (target.indexOf(e) === -1) {
+                    dst.push(e)
+                }
+            }
         })
+    } else {
+        if (target && typeof target === 'object') {
+            Object.keys(target).forEach(function (key) {
+                dst[key] = target[key]
+            })
+        }
+
+        Object.keys(src).forEach(function (key) {
+            if (typeof src[key] !== 'object' || !src[key]) {
+                dst[key] = src[key]
+            }
+            else {
+                dst[key] = merge(target[key], src[key])
+            }
+        })
     }
-    
-    Object.keys(src).forEach(function (key) {
-        if (typeof src[key] !== 'object' || !src[key]) {
-            dst[key] = src[key]
-        }
-        else {
-            dst[key] = merge(target[key], src[key])
-        }
-    })
+
     return dst
 }

package.json

@@ -5,3 +5,3 @@ {
   "description": "A library for deep (recursive) merging of Javascript objects",
-  "version": "0.2.1",
+  "version": "0.2.4",
   "homepage": "https://github.com/nrf110/deepmerge",
@@ -8,0 +8,0 @@ "repository": {

test/merge.js

@@ -5,7 +5,7 @@ var merge = require('../')
 test('add keys in target that do not exist at the root', function (t) {
-    var src = { key1 : 'value1', key2 : 'value2' }
+    var src = { key1: 'value1', key2: 'value2' }
     target = {}
-    
+
     var res = merge(target, src)
-    
+
     t.deepEqual(target, {}, 'merge should be immutable')
@@ -17,11 +17,11 @@ t.deepEqual(res, src)
 test('merge existing simple keys in target at the roots', function (t) {
-    var src = { key1 : 'changed', key2 : 'value2' }
+    var src = { key1: 'changed', key2: 'value2' }
     var target = { key1: 'value1', key3: 'value3' }
-    
+
     var expected = {
-        key1 : 'changed',
-        key2 : 'value2',
-        key3 : 'value3',
+        key1: 'changed',
+        key2: 'value2',
+        key3: 'value3'
     }
-    
+
     t.deepEqual(target, { key1: 'value1', key3: 'value3' })
@@ -34,26 +34,26 @@ t.deepEqual(merge(target, src), expected)
     var src = {
-        key1 : {
-            subkey1 : 'changed',
-            subkey3 : 'added',
+        key1: {
+            subkey1: 'changed',
+            subkey3: 'added'
         }
     }
     var target = {
-        key1 : {
-            subkey1 : 'value1',
-            subkey2 : 'value2',
+        key1: {
+            subkey1: 'value1',
+            subkey2: 'value2'
         }
     }
-    
+
     var expected = {
-        key1 : {
+        key1: {
             subkey1: 'changed',
             subkey2: 'value2',
-            subkey3: 'added',
+            subkey3: 'added'
         }
     }
-    
+
     t.deepEqual(target, {
-        key1 : {
-            subkey1 : 'value1',
-            subkey2 : 'value2',
+        key1: {
+            subkey1: 'value1',
+            subkey2: 'value2'
         }
@@ -67,21 +67,21 @@ })
     var src = {
-        key1 : {
-            subkey1 : 'subvalue1',
-            subkey2 : 'subvalue2',
+        key1: {
+            subkey1: 'subvalue1',
+            subkey2: 'subvalue2'
         }
     }
-    var target = { 
-        key1 : 'value1',
-        key2 : 'value2',
+    var target = {
+        key1: 'value1',
+        key2: 'value2'
     }
 
     var expected = {
-        key1 : {
-            subkey1 : 'subvalue1',
-            subkey2 : 'subvalue2',
+        key1: {
+            subkey1: 'subvalue1',
+            subkey2: 'subvalue2'
         },
-        key2 : 'value2',
+        key2: 'value2'
     }
-    
-    t.deepEqual(target, { key1 : 'value1', key2 : 'value2' })
+
+    t.deepEqual(target, { key1: 'value1', key2: 'value2' })
     t.deepEqual(merge(target, src), expected)
@@ -92,22 +92,87 @@ t.end()
 test('should replace object with simple key in target', function (t) {
-    var src = { key1 : 'value1' }
+    var src = { key1: 'value1' }
     var target = {
-        key1 : {
+        key1: {
             subkey1: 'subvalue1',
-            subkey2: 'subvalue2',
+            subkey2: 'subvalue2'
         },
-        key2 : 'value2',
+        key2: 'value2'
     }
 
-    var expected = { key1 : 'value1', key2 : 'value2' }
-    
+    var expected = { key1: 'value1', key2: 'value2' }
+
     t.deepEqual(target, {
-        key1 : {
+        key1: {
             subkey1: 'subvalue1',
-            subkey2: 'subvalue2',
+            subkey2: 'subvalue2'
         },
-        key2 : 'value2',
-    });
+        key2: 'value2'
+    })
     t.deepEqual(merge(target, src), expected)
     t.end()
 })
+
+test('should work on simple array', function (t) {
+    var src = ['one', 'three']
+    var target = ['one', 'two']
+
+    var expected = ['one', 'two', 'three']
+
+    t.deepEqual(target, ['one', 'two'])
+    t.deepEqual(merge(target, src), expected)
+    t.ok(Array.isArray(merge(target, src)))
+    t.end()
+})
+
+test('should work on array properties', function (t) {
+    var src = {
+        key1: ['one', 'three'],
+        key2: ['four']
+    }
+    var target = {
+        key1: ['one', 'two']
+    }
+
+    var expected = {
+        key1: ['one', 'two', 'three'],
+        key2: ['four']
+    }
+
+    t.deepEqual(target, {
+        key1: ['one', 'two']
+    })
+
+    t.deepEqual(merge(target, src), expected)
+    t.ok(Array.isArray(merge(target, src).key1))
+    t.ok(Array.isArray(merge(target, src).key2))
+    t.end()
+})
+
+test('should work on array of objects', function (t) {
+    var src = [
+        { key1: ['one', 'three'], key2: ['one'] },
+        { key3: ['five'] }
+    ]
+    var target = [
+        { key1: ['one', 'two'] },
+        { key3: ['four'] }
+    ]
+
+    var expected = [
+        { key1: ['one', 'two', 'three'], key2: ['one'] },
+        { key3: ['four', 'five'] }
+    ]
+
+    t.deepEqual(target, [
+        { key1: ['one', 'two'] },
+        { key3: ['four'] }
+    ])
+    t.deepEqual(merge(target, src), expected)
+    t.ok(Array.isArray(merge(target, src)), 'result should be an array')
+    t.ok(Array.isArray(merge(target, src)[0].key1), 'subkey should be an array too')
+
+    t.end()
+})
+
+
+

No alert changes

Improved metrics

Total package byte prevSize

6551

increased by48.78%

Lines of code

181

increased by57.39%

Number of lines in readme file

65

increased by16.07%

No dependency changes