merge-anything 2.2.3 → 2.4.0

package/README.md

@@ -66,6 +66,7 @@ const c = merge(a, b)
 // However, be careful with JavaScript object references. See below: A note on JavaScript object references
 
 // arrays get overwritten
+// (for "concat" logic, see Extensions below)
 merge({array: ['a']}, {array: ['b']}) // returns {array: ['b']}
 
 // empty objects merge into objects
@@ -83,15 +84,54 @@ merge-anything properly keeps special objects intact like dates, regex, function
 
 However, it's **very important** you understand how to work around JavaScript object references. Please be sure to read [a note on JavaScript object references](#a-note-on-javascript-object-references) down below.
 
-## Extend merge rules
+## Extensions & custom rules
 
-merge-anything can be really powerful because every step of the way **you can define rules to extend the overwrite logic.**
+There might be times you need to tweak the logic when two things are merged, eg. you need arrays to be *concatenated* instead of *overwritten*. This is possible through an extension!
 
-### Concat arrays
+To keep the source code _as small as possible_ I opted for an extionsion system where you can import just the logic you need.
 
-Eg. merge-anything will overwrite arrays by default but you could change this logic to make it so it will concat the arrays.
+### Concat arrays extension
 
-To do so your first parameter you pass has to be an object that looks like `{extensions: []}` and include an array of functions. In these functions you can change the value that will be overwriting the origin. See how to do this below:
+```js
+import { merge, concatArrays } from 'merge-anything'
+
+merge(
+  {extensions: [concatArrays]}, // pass your extensions like so
+  {array: ['a']},
+  {array: ['b']}
+)
+// returns {array: ['a', 'b']}
+```
+
+All extensions get triggered at the top level and at every single nested prop. Let's look at two more examples to clarify this:
+
+```js
+// top level:
+merge(
+  {extensions: [concatArrays]},
+  ['a'],
+  ['b']
+)
+// returns ['a', 'b']
+
+// nested props:
+merge(
+  {extensions: [concatArrays]}, // pass your extensions like so
+  {nested: {prop: {array: ['a']}}},
+  {nested: {prop: {array: ['b']}}},
+)
+// returns {nested: {prop: {array: ['a', 'b']}}},
+```
+
+Super simple!
+
+### Making your own extension / custom rule
+
+The `concatArrays` extension imported above is actually just a function that takes both values it's trying to merge, and returns a new value. An "extension" function is triggered at the top level and on any nested props that should be merged.
+
+This means that merge-anything can be really powerful because every step of the way **you can define rules to extend the overwrite logic.** Let's look at the `concatArrays` function as an example to see how you can write your own custom rules:
+
+You have to define a function that receives two parameters. The first is the original value and the second is the new value that's being merged onto the original. When concatenating arrays, you can simply check if the value is an array or not and concatenate if it is.
 
 ```js
 function concatArrays (originVal, newVal) {
@@ -102,29 +142,29 @@ function concatArrays (originVal, newVal) {
   return newVal // always return newVal as fallback!!
 }
 merge(
-  {extensions: [concatArrays]}, // pass your extensions like so
+  {extensions: [concatArrays]}, // pass your custom functions like so
   {array: ['a']},
   {array: ['b']}
 )
 // results in {array: ['a', 'b']}
 ```
 
-Please note that each extension-function receives an `originVal` and `newVal` and **has** to return the `newVal` on fallback no matter what (in case your condition check fails or something)!
+Please note that each extension-function receives an `originVal` and `newVal` and **has** to return the `newVal` on fallback no matter what. Otherwise there might be cases that the original value is overwritten with `undefined`.
 
 ## A note on JavaScript object references
 
 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:
@@ -134,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

@@ -1,7 +1,24 @@
 'use strict';
 
+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)) {
@@ -14,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
@@ -37,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.
@@ -61,7 +78,7 @@ function mergeRecursively(origin, newComer, extensions) {
  * @param {...any[]} newComers
  * @returns the result
  */
-function index (origin) {
+function merge(origin) {
     var newComers = [];
     for (var _i = 1; _i < arguments.length; _i++) {
         newComers[_i - 1] = arguments[_i];
@@ -77,4 +94,14 @@ function index (origin) {
     }, base);
 }
 
-module.exports = index;
+function concatArrays(originVal, newVal) {
+    if (isWhat.isArray(originVal) && isWhat.isArray(newVal)) {
+        // concat logic
+        return originVal.concat(newVal);
+    }
+    return newVal; // always return newVal as fallback!!
+}
+
+exports.merge = merge;
+exports.concatArrays = concatArrays;
+exports.default = merge;

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 index (origin) {
+function merge(origin) {
     var newComers = [];
     for (var _i = 1; _i < arguments.length; _i++) {
         newComers[_i - 1] = arguments[_i];
@@ -75,4 +90,13 @@ function index (origin) {
     }, base);
 }
 
-export default index;
+function concatArrays(originVal, newVal) {
+    if (isArray(originVal) && isArray(newVal)) {
+        // concat logic
+        return originVal.concat(newVal);
+    }
+    return newVal; // always return newVal as fallback!!
+}
+
+export default merge;
+export { merge, concatArrays };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "merge-anything",
-  "version": "2.2.3",
+  "version": "2.4.0",
   "description": "Merge objects & other types recursively. A simple & small integration.",
   "main": "dist/index.cjs.js",
   "module": "dist/index.esm.js",
@@ -44,15 +44,15 @@
   "homepage": "https://github.com/mesqueeb/merge-anything#readme",
   "devDependencies": {
     "@ava/babel-preset-stage-4": "^2.0.0",
-    "@babel/plugin-proposal-object-rest-spread": "^7.0.0",
-    "@babel/preset-env": "^7.1.0",
-    "ava": "1.0.0-beta.8",
-    "copy-anything": "^1.1.1",
+    "@babel/plugin-proposal-object-rest-spread": "^7.5.4",
+    "@babel/preset-env": "^7.5.4",
+    "ava": "^1.4.1",
+    "copy-anything": "^1.2.4",
     "rollup": "^0.65.2",
-    "rollup-plugin-typescript2": "^0.19.2",
-    "typescript": "^3.0.3"
+    "rollup-plugin-typescript2": "^0.21.2",
+    "typescript": "^3.5.3"
   },
   "dependencies": {
-    "is-what": "^3.1.1"
+    "is-what": "^3.2.4"
   }
 }

package/src/extensions.ts

@@ -0,0 +1,9 @@
+import { isArray } from 'is-what'
+
+export function concatArrays (originVal, newVal) {
+  if (isArray(originVal) && isArray(newVal)) {
+    // concat logic
+    return originVal.concat(newVal)
+  }
+  return newVal // always return newVal as fallback!!
+}

package/src/index.ts

@@ -1,78 +1,5 @@
-import { isArray, isPlainObject } from 'is-what'
+import merge from './merge'
+import { concatArrays } from './extensions'
 
-type Extension = (param1: any, param2: any) => any
-
-interface IConfig {
-  extensions: Extension[]
-}
-
-function mergeRecursively(origin: any, newComer: any, extensions: Extension[]) {
-  // work directly on newComer if its not an object
-  if (!isPlainObject(newComer)) {
-    // extend merge rules
-    if (extensions && isArray(extensions)) {
-      extensions.forEach(extend => {
-        newComer = extend(origin, newComer)
-      })
-    }
-    return newComer
-  }
-  // define newObject to merge all values upon
-  const newObject = (isPlainObject(origin))
-    ? Object.keys(origin)
-      .reduce((carry, key) => {
-        const targetVal = origin[key]
-        // @ts-ignore
-        if (!Object.keys(newComer).includes(key)) carry[key] = targetVal
-        return carry
-      }, {})
-    : {}
-  return Object.keys(newComer)
-    .reduce((carry, key) => {
-      // re-define the origin and newComer as targetVal and newVal
-      let newVal = newComer[key]
-      const targetVal = (isPlainObject(origin))
-        ? origin[key]
-        : undefined
-      // extend merge rules
-      if (extensions && isArray(extensions)) {
-        extensions.forEach(extend => {
-          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
-      }
-      // all the rest
-      carry[key] = newVal
-      return carry
-    }, newObject)
-}
-
-/**
- * Merge anything recursively.
- * Objects get merged, special objects (classes etc.) are re-assigned "as is".
- * Basic types overwrite objects or other basic types.
- *
- * @param {(IConfig | any)} origin
- * @param {...any[]} newComers
- * @returns the result
- */
-export default function (origin: IConfig | any, ...newComers: any[]) {
-  let extensions = null
-  let base = origin
-  if (isPlainObject(origin) && origin.extensions && Object.keys(origin).length === 1) {
-    base = {}
-    extensions = origin.extensions
-  }
-  return newComers.reduce((result, newComer) => {
-    return mergeRecursively(result, newComer, extensions)
-  }, base)
-}
+export { merge, concatArrays }
+export default merge

package/src/merge.ts

@@ -0,0 +1,98 @@
+import { isArray, isPlainObject, isSymbol } from 'is-what'
+
+type Extension = (param1: any, param2: any) => any
+
+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)) {
+    // extend merge rules
+    if (extensions && isArray(extensions)) {
+      extensions.forEach(extend => {
+        newComer = extend(origin, newComer)
+      })
+    }
+    return newComer
+  }
+  // define newObject to merge all values upon
+  let newObject = {}
+  if (isPlainObject(origin)) {
+    const props = Object.getOwnPropertyNames(origin)
+    const symbols = Object.getOwnPropertySymbols(origin)
+    newObject = [...props, ...symbols]
+      .reduce((carry, key) => {
+        // @ts-ignore
+        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
+      }, {})
+  }
+  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
+      if (extensions && isArray(extensions)) {
+        extensions.forEach(extend => {
+          newVal = extend(targetVal, newVal)
+        })
+      }
+      // When newVal is an object do the merge recursively
+      if (targetVal !== undefined && isPlainObject(newVal)) {
+        newVal = mergeRecursively(targetVal, newVal, extensions)
+      }
+      assignProp(carry, key, newVal, newComer)
+      return carry
+    }, newObject)
+  return result
+}
+
+/**
+ * Merge anything recursively.
+ * Objects get merged, special objects (classes etc.) are re-assigned "as is".
+ * Basic types overwrite objects or other basic types.
+ *
+ * @param {(IConfig | any)} origin
+ * @param {...any[]} newComers
+ * @returns the result
+ */
+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) {
+    base = {}
+    extensions = origin.extensions
+  }
+  return newComers.reduce((result, newComer) => {
+    return mergeRecursively(result, newComer, extensions)
+  }, base)
+}

package/test/index.js

@@ -1,5 +1,6 @@
 import test from 'ava'
 import merge from '../dist/index.cjs'
+import { concatArrays } from '../dist/index.cjs'
 import copy from 'copy-anything'
 import { isDate, isFunction, isString, isArray, isObject } from 'is-what'
 
@@ -160,7 +161,7 @@ test('Extend conversion', t => {
 })
 test('Extend concat arrays', t => {
   let res, origin, target
-  function concatArrays (originVal, targetVal) {
+  function concatArr (originVal, targetVal) {
     if (isArray(originVal) && isArray(targetVal)) {
       return originVal.concat(targetVal)
     }
@@ -174,6 +175,22 @@ test('Extend concat arrays', t => {
     someArray: ['b'],
     a: {b: {c: ['y']}}
   }
+  res = merge({extensions: [concatArr]}, origin, target)
+  t.deepEqual(res, {someArray: ['a', 'b'], a: {b: {c: ['x', 'y']}}})
+  // also works on base lvl
+  res = merge({extensions: [concatArr]}, ['a'], ['b'])
+  t.deepEqual(res, ['a', 'b'])
+})
+test('import concat array extension', t => {
+  let res, origin, target
+  origin = {
+    someArray: ['a'],
+    a: {b: {c: ['x']}}
+  }
+  target = {
+    someArray: ['b'],
+    a: {b: {c: ['y']}}
+  }
   res = merge({extensions: [concatArrays]}, origin, target)
   t.deepEqual(res, {someArray: ['a', 'b'], a: {b: {c: ['x', 'y']}}})
   // also works on base lvl
@@ -353,3 +370,60 @@ test('works with unlimited depth', t => {
   t.deepEqual(t3, {t3: 'new'})
   t.deepEqual(t4, {t4: 'new', t3: {}})
 })
+
+test('symbols as keys', t => {
+  let res, x, y
+  const mySymbol = Symbol('mySymbol')
+  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/extensions.d.ts

@@ -0,0 +1 @@
+export declare function concatArrays(originVal: any, newVal: any): any;

package/types/index.d.ts

@@ -1,15 +1,4 @@
-declare type Extension = (param1: any, param2: any) => any;
-interface IConfig {
-    extensions: Extension[];
-}
-/**
- * Merge anything recursively.
- * Objects get merged, special objects (classes etc.) are re-assigned "as is".
- * Basic types overwrite objects or other basic types.
- *
- * @param {(IConfig | any)} origin
- * @param {...any[]} newComers
- * @returns the result
- */
-export default function (origin: IConfig | any, ...newComers: any[]): any;
-export {};
+import merge from './merge';
+import { concatArrays } from './extensions';
+export { merge, concatArrays };
+export default merge;

package/types/merge.d.ts

@@ -0,0 +1,15 @@
+declare type Extension = (param1: any, param2: any) => any;
+interface IConfig {
+    extensions: Extension[];
+}
+/**
+ * Merge anything recursively.
+ * Objects get merged, special objects (classes etc.) are re-assigned "as is".
+ * Basic types overwrite objects or other basic types.
+ *
+ * @param {(IConfig | any)} origin
+ * @param {...any[]} newComers
+ * @returns the result
+ */
+export default function merge(origin: IConfig | any, ...newComers: any[]): any;
+export {};