merge-anything 2.3.5 → 2.4.0

package/README.md

@@ -119,7 +119,6 @@ merge(
   {extensions: [concatArrays]}, // pass your extensions like so
   {nested: {prop: {array: ['a']}}},
   {nested: {prop: {array: ['b']}}},
-  {array: ['b']}
 )
 // returns {nested: {prop: {array: ['a', 'b']}}},
 ```
@@ -157,15 +156,15 @@ Please note that each extension-function receives an `originVal` and `newVal` an
 Be careful for JavaScript object reference. Any property that's nested will be reactive and linked between the original and the merged objects! Down below we'll show how to prevent this.
 
 ```js
-const original = {airport: {airplane: '🛫'}}
-const new = {country: {location: 'Brussels'}}
-const merged = merge(original, merged)
+const original = {airport: {airplane: 'dep. 🛫'}}
+const extraInfo = {airport: {location: 'Brussels'}}
+const merged = merge(original, extraInfo)
 
 // we change the airplane from departuring 🛫 to landing 🛬
-original.airport.airplane = '🛬'
-// This will change the value for `original` AND `merged`!!!
-original.airport.airplane === '🛬' // true
-merged.airport.airplane === '🛬' // true
+merged.airport.airplane = 'lan. 🛬'
+(merged.airport.airplane === 'lan. 🛬') // true
+// However, `original` was also modified!
+(original.airport.airplane === 'lan. 🛬') // true
 ```
 
 The key rule to remember is:
@@ -175,21 +174,23 @@ The key rule to remember is:
 However, **there is a really easy solution**. We can just copy the merge result to get rid of any reactivity. For this we can use the [copy-anything](https://github.com/mesqueeb/copy-anything) library. This library also makes sure that _special class instances do not break_, so you can use it without fear of breaking stuff!
 
 See below how we integrate 'copy-anything':
+
 ```js
 import copy from 'copy-anything'
 
-const original = {airport: {airplane: '🛫'}}
-const new = {country: {location: 'Brussels'}}
-const merged = merge(original, merged)
-const mergedNotReactive = copy(merged)
+const original = {airport: {airplane: 'dep. 🛫'}}
+const extraInfo = {airport: {location: 'Brussels'}}
+const merged = copy(merge(original, extraInfo))
 
 // we change the airplane from departuring 🛫 to landing 🛬
-original.airport.airplane = '🛬'
-// `original` and `mergedNotReactive` are not linked anymore!
-original.airport.airplane === '🛬' // true
-mergedNotReactive.airport.airplane === '🛫' // true
+merged.airport.airplane = 'lan. 🛬'
+(merged.airport.airplane === 'lan. 🛬') // true
+// `original` won't be modified!
+(original.airport.airplane === 'lan. 🛬') // true
 ```
 
+You can then play around where you want to place the `copy()` function.
+
 ## Source code
 
 It is literally just going through an object recursively and assigning the values to a new object like below. However, it's wrapped to allow extra params etc. The code below is the basic integration, that will make you understand the basics how it works.

package/dist/index.cjs.js

@@ -4,6 +4,21 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var isWhat = require('is-what');
 
+function assignProp(carry, key, newVal, originalObject) {
+    var propType = originalObject.propertyIsEnumerable(key)
+        ? 'enumerable'
+        : 'nonenumerable';
+    if (propType === 'enumerable')
+        carry[key] = newVal;
+    if (propType === 'nonenumerable') {
+        Object.defineProperty(carry, key, {
+            value: newVal,
+            enumerable: false,
+            writable: true,
+            configurable: true
+        });
+    }
+}
 function mergeRecursively(origin, newComer, extensions) {
     // work directly on newComer if its not an object
     if (!isWhat.isPlainObject(newComer)) {
@@ -16,21 +31,27 @@ function mergeRecursively(origin, newComer, extensions) {
         return newComer;
     }
     // define newObject to merge all values upon
-    var newObject = (isWhat.isPlainObject(origin))
-        ? Object.keys(origin)
-            .reduce(function (carry, key) {
-            var targetVal = origin[key];
+    var newObject = {};
+    if (isWhat.isPlainObject(origin)) {
+        var props_1 = Object.getOwnPropertyNames(origin);
+        var symbols_1 = Object.getOwnPropertySymbols(origin);
+        newObject = props_1.concat(symbols_1).reduce(function (carry, key) {
             // @ts-ignore
-            if (!Object.keys(newComer).includes(key))
-                carry[key] = targetVal;
+            var targetVal = origin[key];
+            if ((!isWhat.isSymbol(key) && !Object.getOwnPropertyNames(newComer).includes(key)) ||
+                (isWhat.isSymbol(key) && !Object.getOwnPropertySymbols(newComer).includes(key))) {
+                assignProp(carry, key, targetVal, origin);
+            }
             return carry;
-        }, {})
-        : {};
-    return Object.keys(newComer)
-        .reduce(function (carry, key) {
+        }, {});
+    }
+    var props = Object.getOwnPropertyNames(newComer);
+    var symbols = Object.getOwnPropertySymbols(newComer);
+    var result = props.concat(symbols).reduce(function (carry, key) {
         // re-define the origin and newComer as targetVal and newVal
         var newVal = newComer[key];
         var targetVal = (isWhat.isPlainObject(origin))
+            // @ts-ignore
             ? origin[key]
             : undefined;
         // extend merge rules
@@ -39,20 +60,14 @@ function mergeRecursively(origin, newComer, extensions) {
                 newVal = extend(targetVal, newVal);
             });
         }
-        // early return when targetVal === undefined
-        if (targetVal === undefined) {
-            carry[key] = newVal;
-            return carry;
-        }
         // When newVal is an object do the merge recursively
-        if (isWhat.isPlainObject(newVal)) {
-            carry[key] = mergeRecursively(targetVal, newVal, extensions);
-            return carry;
+        if (targetVal !== undefined && isWhat.isPlainObject(newVal)) {
+            newVal = mergeRecursively(targetVal, newVal, extensions);
         }
-        // all the rest
-        carry[key] = newVal;
+        assignProp(carry, key, newVal, newComer);
         return carry;
     }, newObject);
+    return result;
 }
 /**
  * Merge anything recursively.
@@ -63,7 +78,7 @@ function mergeRecursively(origin, newComer, extensions) {
  * @param {...any[]} newComers
  * @returns the result
  */
-function merge (origin) {
+function merge(origin) {
     var newComers = [];
     for (var _i = 1; _i < arguments.length; _i++) {
         newComers[_i - 1] = arguments[_i];

package/dist/index.esm.js

@@ -1,5 +1,20 @@
-import { isArray, isPlainObject } from 'is-what';
+import { isArray, isPlainObject, isSymbol } from 'is-what';
 
+function assignProp(carry, key, newVal, originalObject) {
+    var propType = originalObject.propertyIsEnumerable(key)
+        ? 'enumerable'
+        : 'nonenumerable';
+    if (propType === 'enumerable')
+        carry[key] = newVal;
+    if (propType === 'nonenumerable') {
+        Object.defineProperty(carry, key, {
+            value: newVal,
+            enumerable: false,
+            writable: true,
+            configurable: true
+        });
+    }
+}
 function mergeRecursively(origin, newComer, extensions) {
     // work directly on newComer if its not an object
     if (!isPlainObject(newComer)) {
@@ -12,21 +27,27 @@ function mergeRecursively(origin, newComer, extensions) {
         return newComer;
     }
     // define newObject to merge all values upon
-    var newObject = (isPlainObject(origin))
-        ? Object.keys(origin)
-            .reduce(function (carry, key) {
-            var targetVal = origin[key];
+    var newObject = {};
+    if (isPlainObject(origin)) {
+        var props_1 = Object.getOwnPropertyNames(origin);
+        var symbols_1 = Object.getOwnPropertySymbols(origin);
+        newObject = props_1.concat(symbols_1).reduce(function (carry, key) {
             // @ts-ignore
-            if (!Object.keys(newComer).includes(key))
-                carry[key] = targetVal;
+            var targetVal = origin[key];
+            if ((!isSymbol(key) && !Object.getOwnPropertyNames(newComer).includes(key)) ||
+                (isSymbol(key) && !Object.getOwnPropertySymbols(newComer).includes(key))) {
+                assignProp(carry, key, targetVal, origin);
+            }
             return carry;
-        }, {})
-        : {};
-    return Object.keys(newComer)
-        .reduce(function (carry, key) {
+        }, {});
+    }
+    var props = Object.getOwnPropertyNames(newComer);
+    var symbols = Object.getOwnPropertySymbols(newComer);
+    var result = props.concat(symbols).reduce(function (carry, key) {
         // re-define the origin and newComer as targetVal and newVal
         var newVal = newComer[key];
         var targetVal = (isPlainObject(origin))
+            // @ts-ignore
             ? origin[key]
             : undefined;
         // extend merge rules
@@ -35,20 +56,14 @@ function mergeRecursively(origin, newComer, extensions) {
                 newVal = extend(targetVal, newVal);
             });
         }
-        // early return when targetVal === undefined
-        if (targetVal === undefined) {
-            carry[key] = newVal;
-            return carry;
-        }
         // When newVal is an object do the merge recursively
-        if (isPlainObject(newVal)) {
-            carry[key] = mergeRecursively(targetVal, newVal, extensions);
-            return carry;
+        if (targetVal !== undefined && isPlainObject(newVal)) {
+            newVal = mergeRecursively(targetVal, newVal, extensions);
         }
-        // all the rest
-        carry[key] = newVal;
+        assignProp(carry, key, newVal, newComer);
         return carry;
     }, newObject);
+    return result;
 }
 /**
  * Merge anything recursively.
@@ -59,7 +74,7 @@ function mergeRecursively(origin, newComer, extensions) {
  * @param {...any[]} newComers
  * @returns the result
  */
-function merge (origin) {
+function merge(origin) {
     var newComers = [];
     for (var _i = 1; _i < arguments.length; _i++) {
         newComers[_i - 1] = arguments[_i];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "merge-anything",
-  "version": "2.3.5",
+  "version": "2.4.0",
   "description": "Merge objects & other types recursively. A simple & small integration.",
   "main": "dist/index.cjs.js",
   "module": "dist/index.esm.js",

package/src/merge.ts

@@ -1,4 +1,4 @@
-import { isArray, isPlainObject } from 'is-what'
+import { isArray, isPlainObject, isSymbol } from 'is-what'
 
 type Extension = (param1: any, param2: any) => any
 
@@ -6,6 +6,21 @@ interface IConfig {
   extensions: Extension[]
 }
 
+function assignProp (carry, key, newVal, originalObject) {
+  const propType = originalObject.propertyIsEnumerable(key)
+    ? 'enumerable'
+    : 'nonenumerable'
+  if (propType === 'enumerable') carry[key] = newVal
+  if (propType === 'nonenumerable') {
+    Object.defineProperty(carry, key, {
+      value: newVal,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    })
+  }
+}
+
 function mergeRecursively(origin: any, newComer: any, extensions: Extension[]) {
   // work directly on newComer if its not an object
   if (!isPlainObject(newComer)) {
@@ -18,20 +33,31 @@ function mergeRecursively(origin: any, newComer: any, extensions: Extension[]) {
     return newComer
   }
   // define newObject to merge all values upon
-  const newObject = (isPlainObject(origin))
-    ? Object.keys(origin)
+  let newObject = {}
+  if (isPlainObject(origin)) {
+    const props = Object.getOwnPropertyNames(origin)
+    const symbols = Object.getOwnPropertySymbols(origin)
+    newObject = [...props, ...symbols]
       .reduce((carry, key) => {
-        const targetVal = origin[key]
         // @ts-ignore
-        if (!Object.keys(newComer).includes(key)) carry[key] = targetVal
+        const targetVal = origin[key]
+        if (
+          (!isSymbol(key) && !Object.getOwnPropertyNames(newComer).includes(key)) ||
+          (isSymbol(key) && !Object.getOwnPropertySymbols(newComer).includes(key))
+        ) {
+          assignProp(carry, key, targetVal, origin)
+        }
         return carry
       }, {})
-    : {}
-  return Object.keys(newComer)
+  }
+  const props = Object.getOwnPropertyNames(newComer)
+  const symbols = Object.getOwnPropertySymbols(newComer)
+  let result = [...props, ...symbols]
     .reduce((carry, key) => {
       // re-define the origin and newComer as targetVal and newVal
       let newVal = newComer[key]
       const targetVal = (isPlainObject(origin))
+        // @ts-ignore
         ? origin[key]
         : undefined
       // extend merge rules
@@ -40,20 +66,14 @@ function mergeRecursively(origin: any, newComer: any, extensions: Extension[]) {
           newVal = extend(targetVal, newVal)
         })
       }
-      // early return when targetVal === undefined
-      if (targetVal === undefined) {
-        carry[key] = newVal
-        return carry
-      }
       // When newVal is an object do the merge recursively
-      if (isPlainObject(newVal)) {
-        carry[key] = mergeRecursively(targetVal, newVal, extensions)
-        return carry
+      if (targetVal !== undefined && isPlainObject(newVal)) {
+        newVal = mergeRecursively(targetVal, newVal, extensions)
       }
-      // all the rest
-      carry[key] = newVal
+      assignProp(carry, key, newVal, newComer)
       return carry
     }, newObject)
+  return result
 }
 
 /**
@@ -65,7 +85,7 @@ function mergeRecursively(origin: any, newComer: any, extensions: Extension[]) {
  * @param {...any[]} newComers
  * @returns the result
  */
-export default function (origin: IConfig | any, ...newComers: any[]) {
+export default function merge (origin: IConfig | any, ...newComers: any[]) {
   let extensions = null
   let base = origin
   if (isPlainObject(origin) && origin.extensions && Object.keys(origin).length === 1) {

package/test/index.js

@@ -372,11 +372,58 @@ test('works with unlimited depth', t => {
 })
 
 test('symbols as keys', t => {
+  let res, x, y
   const mySymbol = Symbol('mySymbol')
-  const x = { value: 42, [mySymbol]: 'hello' }
-  const y = { other: 33 }
-  const res = merge(x, y)
+  x = { value: 42, [mySymbol]: 'hello' }
+  y = { other: 33 }
+  res = merge(x, y)
   t.is(res.value, 42)
   t.is(res.other, 33)
   t.is(res[mySymbol], 'hello')
+  x = { value: 42 }
+  y = { other: 33, [mySymbol]: 'hello' }
+  res = merge(x, y)
+  t.is(res.value, 42)
+  t.is(res.other, 33)
+  t.is(res[mySymbol], 'hello')
+})
+
+test('nonenumerable keys', t => {
+  let x, y, res
+  const mySymbol = Symbol('mySymbol')
+  x = { value: 42 }
+  y = { other: 33 }
+  Object.defineProperty(x, 'xid', {
+    value: 1,
+    writable: true,
+    enumerable: false,
+    configurable: true
+  })
+  Object.defineProperty(x, mySymbol, {
+    value: 'original',
+    writable: true,
+    enumerable: false,
+    configurable: true
+  })
+  Object.defineProperty(y, 'yid', {
+    value: 2,
+    writable: true,
+    enumerable: false,
+    configurable: true
+  })
+  Object.defineProperty(y, mySymbol, {
+    value: 'new',
+    writable: true,
+    enumerable: false,
+    configurable: true
+  })
+  res = merge(x, y)
+  t.is(res.value, 42)
+  t.is(res.other, 33)
+  t.is(res.xid, 1)
+  t.is(res.yid, 2)
+  t.is(res[mySymbol], 'new')
+  t.is(Object.keys(res).length, 2)
+  t.true(Object.keys(res).includes('value'))
+  t.true(Object.keys(res).includes('other'))
 })

package/types/merge.d.ts

@@ -11,5 +11,5 @@ interface IConfig {
  * @param {...any[]} newComers
  * @returns the result
  */
-export default function (origin: IConfig | any, ...newComers: any[]): any;
+export default function merge(origin: IConfig | any, ...newComers: any[]): any;
 export {};