merge-anything 4.0.2 → 4.0.3

package/README.md

@@ -1,5 +1,8 @@
 # Merge anything 🥡
 
+<a href="https://www.npmjs.com/package/merge-anything"><img src="https://img.shields.io/npm/v/merge-anything.svg" alt="Total Downloads"></a>
+<a href="https://www.npmjs.com/package/merge-anything"><img src="https://img.shields.io/npm/dw/merge-anything.svg" alt="Latest Stable Version"></a>
+
 ```
 npm i merge-anything
 ```

package/dist/index.cjs

@@ -0,0 +1,92 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var isWhat = require('is-what');
+
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+function concatArrays(originVal, newVal) {
+    if (isWhat.isArray(originVal) && isWhat.isArray(newVal)) {
+        // concat logic
+        return originVal.concat(newVal);
+    }
+    return newVal; // always return newVal as fallback!!
+}
+
+function assignProp(carry, key, newVal, originalObject) {
+    const propType = {}.propertyIsEnumerable.call(originalObject, 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, compareFn) {
+    // always return newComer if its not an object
+    if (!isWhat.isPlainObject(newComer))
+        return newComer;
+    // define newObject to merge all values upon
+    let newObject = {};
+    if (isWhat.isPlainObject(origin)) {
+        const props = Object.getOwnPropertyNames(origin);
+        const symbols = Object.getOwnPropertySymbols(origin);
+        newObject = [...props, ...symbols].reduce((carry, key) => {
+            const 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;
+        }, {});
+    }
+    // newObject has all properties that newComer hasn't
+    const props = Object.getOwnPropertyNames(newComer);
+    const symbols = Object.getOwnPropertySymbols(newComer);
+    const result = [...props, ...symbols].reduce((carry, key) => {
+        // re-define the origin and newComer as targetVal and newVal
+        let newVal = newComer[key];
+        const targetVal = isWhat.isPlainObject(origin) ? origin[key] : undefined;
+        // When newVal is an object do the merge recursively
+        if (targetVal !== undefined && isWhat.isPlainObject(newVal)) {
+            newVal = mergeRecursively(targetVal, newVal, compareFn);
+        }
+        const propToAssign = compareFn ? compareFn(targetVal, newVal, key) : newVal;
+        assignProp(carry, key, propToAssign, 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 object
+ * @param otherObjects
+ */
+function merge(object, ...otherObjects) {
+    return otherObjects.reduce((result, newComer) => {
+        return mergeRecursively(result, newComer);
+    }, object);
+}
+function mergeAndCompare(compareFn, object, ...otherObjects) {
+    return otherObjects.reduce((result, newComer) => {
+        return mergeRecursively(result, newComer, compareFn);
+    }, object);
+}
+function mergeAndConcat(object, ...otherObjects) {
+    return otherObjects.reduce((result, newComer) => {
+        return mergeRecursively(result, newComer, concatArrays);
+    }, object);
+}
+
+exports.concatArrays = concatArrays;
+exports.merge = merge;
+exports.mergeAndCompare = mergeAndCompare;
+exports.mergeAndConcat = mergeAndConcat;

package/dist/index.es.js

@@ -0,0 +1,85 @@
+import { isArray, isPlainObject, isSymbol } from 'is-what';
+
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+function concatArrays(originVal, newVal) {
+    if (isArray(originVal) && isArray(newVal)) {
+        // concat logic
+        return originVal.concat(newVal);
+    }
+    return newVal; // always return newVal as fallback!!
+}
+
+function assignProp(carry, key, newVal, originalObject) {
+    const propType = {}.propertyIsEnumerable.call(originalObject, 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, compareFn) {
+    // always return newComer if its not an object
+    if (!isPlainObject(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) => {
+            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;
+        }, {});
+    }
+    // newObject has all properties that newComer hasn't
+    const props = Object.getOwnPropertyNames(newComer);
+    const symbols = Object.getOwnPropertySymbols(newComer);
+    const result = [...props, ...symbols].reduce((carry, key) => {
+        // re-define the origin and newComer as targetVal and newVal
+        let newVal = newComer[key];
+        const targetVal = isPlainObject(origin) ? origin[key] : undefined;
+        // When newVal is an object do the merge recursively
+        if (targetVal !== undefined && isPlainObject(newVal)) {
+            newVal = mergeRecursively(targetVal, newVal, compareFn);
+        }
+        const propToAssign = compareFn ? compareFn(targetVal, newVal, key) : newVal;
+        assignProp(carry, key, propToAssign, 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 object
+ * @param otherObjects
+ */
+function merge(object, ...otherObjects) {
+    return otherObjects.reduce((result, newComer) => {
+        return mergeRecursively(result, newComer);
+    }, object);
+}
+function mergeAndCompare(compareFn, object, ...otherObjects) {
+    return otherObjects.reduce((result, newComer) => {
+        return mergeRecursively(result, newComer, compareFn);
+    }, object);
+}
+function mergeAndConcat(object, ...otherObjects) {
+    return otherObjects.reduce((result, newComer) => {
+        return mergeRecursively(result, newComer, concatArrays);
+    }, object);
+}
+
+export { concatArrays, merge, mergeAndCompare, mergeAndConcat };

package/package.json

@@ -1,17 +1,31 @@
 {
   "name": "merge-anything",
-  "version": "4.0.2",
+  "version": "4.0.3",
   "sideEffects": false,
+  "type": "module",
   "description": "Merge objects & other types recursively. A simple & small integration.",
-  "main": "dist/index.cjs.js",
-  "module": "dist/index.esm.js",
-  "types": "types/index.d.ts",
+  "module": "./dist/index.es.js",
+  "main": "./dist/index.cjs",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.es.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/types/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=12.13",
+    "npm": ">=7"
+  },
   "scripts": {
-    "lint": "eslint src/ --ext .js,.jsx,.ts,.tsx",
-    "test": "ava",
-    "rollup": "rollup -c build/rollup.js",
-    "build": "npm run lint && npm run test && npm run rollup",
-    "release": "npm run build && np"
+    "lint": "tsc --noEmit && eslint ./src --ext .ts",
+    "test": "vitest run",
+    "build": "rollup -c ./scripts/build.js",
+    "release": "npm run lint && del dist && npm run build && np"
   },
   "repository": {
     "type": "git",
@@ -40,44 +54,41 @@
     "nested-combine"
   ],
   "author": "Luca Ban - Mesqueeb",
+  "funding": "https://github.com/sponsors/mesqueeb",
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/mesqueeb/merge-anything/issues"
   },
   "homepage": "https://github.com/mesqueeb/merge-anything#readme",
   "dependencies": {
-    "is-what": "^3.14.1",
+    "is-what": "^4.1.1",
     "ts-toolbelt": "^9.6.0"
   },
   "devDependencies": {
-    "@typescript-eslint/eslint-plugin": "^5.3.1",
-    "@typescript-eslint/parser": "^5.3.1",
-    "ava": "^3.15.0",
-    "eslint": "^8.2.0",
+    "@typescript-eslint/eslint-plugin": "^5.10.1",
+    "@typescript-eslint/parser": "^5.10.1",
+    "del-cli": "^4.0.1",
+    "eslint": "^8.7.0",
     "eslint-config-prettier": "^8.3.0",
-    "eslint-plugin-tree-shaking": "^1.9.2",
-    "np": "^7.5.0",
-    "prettier": "^2.4.1",
-    "rollup": "^2.59.0",
-    "rollup-plugin-typescript2": "^0.30.0",
-    "ts-node": "^10.4.0",
-    "tsconfig-paths": "^3.11.0",
-    "typescript": "^4.4.4"
-  },
-  "ava": {
-    "extensions": [
-      "ts"
-    ],
-    "require": [
-      "tsconfig-paths/register",
-      "ts-node/register"
-    ]
+    "eslint-plugin-tree-shaking": "^1.10.0",
+    "np": "^7.6.0",
+    "prettier": "^2.5.1",
+    "rollup": "^2.66.0",
+    "rollup-plugin-typescript2": "^0.31.1",
+    "typescript": "^4.5.5",
+    "vitest": "^0.2.1"
   },
   "np": {
     "yarn": false,
     "branch": "production"
   },
   "eslintConfig": {
+    "ignorePatterns": [
+      "node_modules",
+      "dist",
+      "scripts",
+      "test"
+    ],
     "root": true,
     "parser": "@typescript-eslint/parser",
     "plugins": [
@@ -91,6 +102,7 @@
       "prettier"
     ],
     "rules": {
+      "@typescript-eslint/no-empty-function": "off",
       "@typescript-eslint/no-explicit-any": "off",
       "@typescript-eslint/ban-ts-ignore": "off",
       "tree-shaking/no-side-effects-in-initialization": "error",

package/.eslintignore

@@ -1,9 +0,0 @@
-# don't ever lint node_modules
-node_modules
-# don't lint build output (make sure it's set to your correct build folder name)
-dist
-# don't lint nyc coverage output
-coverage
-
-test
-.eslintrc.js

package/.github/FUNDING.yml

@@ -1,12 +0,0 @@
-# These are supported funding model platforms
-
-github: mesqueeb
-patreon: # Replace with a single Patreon username
-open_collective: # Replace with a single Open Collective username
-ko_fi: # Replace with a single Ko-fi username
-tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
-community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
-liberapay: # Replace with a single Liberapay username
-issuehunt: # Replace with a single IssueHunt username
-otechie: # Replace with a single Otechie username
-custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

package/.prettierrc

@@ -1,9 +0,0 @@
-{
-  "printWidth": 100,
-  "tabWidth": 2,
-  "singleQuote": true,
-  "trailingComma": "es5",
-  "semi": false,
-  "bracketSpacing": true,
-  "quoteProps": "consistent"
-}

package/build/rollup.js

@@ -1,57 +0,0 @@
-/* eslint-disable */
-
-// npm i -D rollup-plugin-typescript2 typescript
-import typescript from 'rollup-plugin-typescript2'
-
-// ------------------------------------------------------------------------------------------
-// formats
-// ------------------------------------------------------------------------------------------
-// amd – Asynchronous Module Definition, used with module loaders like RequireJS
-// cjs – CommonJS, suitable for Node and Browserify/Webpack
-// esm – Keep the bundle as an ES module file
-// iife – A self-executing function, suitable for inclusion as a <script> tag. (If you want to create a bundle for your application, you probably want to use this, because it leads to smaller file sizes.)
-// umd – Universal Module Definition, works as amd, cjs and iife all in one
-// system – Native format of the SystemJS loader
-
-// ------------------------------------------------------------------------------------------
-// setup
-// ------------------------------------------------------------------------------------------
-const pkg = require('../package.json')
-const name = pkg.name
-const className = name.replace(/(^\w|-\w)/g, c => c.replace('-', '').toUpperCase())
-const external = Object.keys(pkg.dependencies || [])
-const plugins = [
-  typescript({ useTsconfigDeclarationDir: true, tsconfigOverride: { exclude: ['test/**/*'] } }),
-]
-
-// ------------------------------------------------------------------------------------------
-// Builds
-// ------------------------------------------------------------------------------------------
-function defaults (config) {
-  // defaults
-  const defaults = {
-    plugins,
-    external,
-  }
-  // defaults.output
-  config.output = config.output.map(output => {
-    return Object.assign(
-      {
-        sourcemap: false,
-        name: className,
-      },
-      output
-    )
-  })
-  return Object.assign(defaults, config)
-}
-
-export default [
-  defaults({
-    input: 'src/index.ts',
-    output: [
-      { file: 'dist/index.cjs.js', format: 'cjs' },
-      { file: 'dist/index.esm.js', format: 'esm' },
-    ],
-  }),
-]

package/dist/index.cjs.js

@@ -1,125 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var isWhat = require('is-what');
-
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __spreadArray(to, from) {
-    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-        to[j] = from[i];
-    return to;
-}
-
-/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
-function concatArrays(originVal, newVal) {
-    if (isWhat.isArray(originVal) && isWhat.isArray(newVal)) {
-        // concat logic
-        return originVal.concat(newVal);
-    }
-    return newVal; // always return newVal as fallback!!
-}
-
-function assignProp(carry, key, newVal, originalObject) {
-    var propType = {}.propertyIsEnumerable.call(originalObject, 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, compareFn) {
-    // always return newComer if its not an object
-    if (!isWhat.isPlainObject(newComer))
-        return newComer;
-    // define newObject to merge all values upon
-    var newObject = {};
-    if (isWhat.isPlainObject(origin)) {
-        var props_1 = Object.getOwnPropertyNames(origin);
-        var symbols_1 = Object.getOwnPropertySymbols(origin);
-        newObject = __spreadArray(__spreadArray([], props_1), symbols_1).reduce(function (carry, key) {
-            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;
-        }, {});
-    }
-    // newObject has all properties that newComer hasn't
-    var props = Object.getOwnPropertyNames(newComer);
-    var symbols = Object.getOwnPropertySymbols(newComer);
-    var result = __spreadArray(__spreadArray([], props), symbols).reduce(function (carry, key) {
-        // re-define the origin and newComer as targetVal and newVal
-        var newVal = newComer[key];
-        var targetVal = isWhat.isPlainObject(origin) ? origin[key] : undefined;
-        // When newVal is an object do the merge recursively
-        if (targetVal !== undefined && isWhat.isPlainObject(newVal)) {
-            newVal = mergeRecursively(targetVal, newVal, compareFn);
-        }
-        var propToAssign = compareFn ? compareFn(targetVal, newVal, key) : newVal;
-        assignProp(carry, key, propToAssign, 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 object
- * @param otherObjects
- */
-function merge(object) {
-    var otherObjects = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        otherObjects[_i - 1] = arguments[_i];
-    }
-    return otherObjects.reduce(function (result, newComer) {
-        return mergeRecursively(result, newComer);
-    }, object);
-}
-function mergeAndCompare(compareFn, object) {
-    var otherObjects = [];
-    for (var _i = 2; _i < arguments.length; _i++) {
-        otherObjects[_i - 2] = arguments[_i];
-    }
-    return otherObjects.reduce(function (result, newComer) {
-        return mergeRecursively(result, newComer, compareFn);
-    }, object);
-}
-function mergeAndConcat(object) {
-    var otherObjects = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        otherObjects[_i - 1] = arguments[_i];
-    }
-    return otherObjects.reduce(function (result, newComer) {
-        return mergeRecursively(result, newComer, concatArrays);
-    }, object);
-}
-
-exports.concatArrays = concatArrays;
-exports.merge = merge;
-exports.mergeAndCompare = mergeAndCompare;
-exports.mergeAndConcat = mergeAndConcat;

package/dist/index.esm.js

@@ -1,118 +0,0 @@
-import { isArray, isPlainObject, isSymbol } from 'is-what';
-
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __spreadArray(to, from) {
-    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-        to[j] = from[i];
-    return to;
-}
-
-/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
-function concatArrays(originVal, newVal) {
-    if (isArray(originVal) && isArray(newVal)) {
-        // concat logic
-        return originVal.concat(newVal);
-    }
-    return newVal; // always return newVal as fallback!!
-}
-
-function assignProp(carry, key, newVal, originalObject) {
-    var propType = {}.propertyIsEnumerable.call(originalObject, 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, compareFn) {
-    // always return newComer if its not an object
-    if (!isPlainObject(newComer))
-        return newComer;
-    // define newObject to merge all values upon
-    var newObject = {};
-    if (isPlainObject(origin)) {
-        var props_1 = Object.getOwnPropertyNames(origin);
-        var symbols_1 = Object.getOwnPropertySymbols(origin);
-        newObject = __spreadArray(__spreadArray([], props_1), symbols_1).reduce(function (carry, key) {
-            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;
-        }, {});
-    }
-    // newObject has all properties that newComer hasn't
-    var props = Object.getOwnPropertyNames(newComer);
-    var symbols = Object.getOwnPropertySymbols(newComer);
-    var result = __spreadArray(__spreadArray([], props), symbols).reduce(function (carry, key) {
-        // re-define the origin and newComer as targetVal and newVal
-        var newVal = newComer[key];
-        var targetVal = isPlainObject(origin) ? origin[key] : undefined;
-        // When newVal is an object do the merge recursively
-        if (targetVal !== undefined && isPlainObject(newVal)) {
-            newVal = mergeRecursively(targetVal, newVal, compareFn);
-        }
-        var propToAssign = compareFn ? compareFn(targetVal, newVal, key) : newVal;
-        assignProp(carry, key, propToAssign, 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 object
- * @param otherObjects
- */
-function merge(object) {
-    var otherObjects = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        otherObjects[_i - 1] = arguments[_i];
-    }
-    return otherObjects.reduce(function (result, newComer) {
-        return mergeRecursively(result, newComer);
-    }, object);
-}
-function mergeAndCompare(compareFn, object) {
-    var otherObjects = [];
-    for (var _i = 2; _i < arguments.length; _i++) {
-        otherObjects[_i - 2] = arguments[_i];
-    }
-    return otherObjects.reduce(function (result, newComer) {
-        return mergeRecursively(result, newComer, compareFn);
-    }, object);
-}
-function mergeAndConcat(object) {
-    var otherObjects = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        otherObjects[_i - 1] = arguments[_i];
-    }
-    return otherObjects.reduce(function (result, newComer) {
-        return mergeRecursively(result, newComer, concatArrays);
-    }, object);
-}
-
-export { concatArrays, merge, mergeAndCompare, mergeAndConcat };

package/src/extensions.ts

@@ -1,10 +0,0 @@
-/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
-import { isArray } from 'is-what'
-
-export function concatArrays (originVal: any, newVal: any): any | any[] {
-  if (isArray(originVal) && isArray(newVal)) {
-    // concat logic
-    return originVal.concat(newVal)
-  }
-  return newVal // always return newVal as fallback!!
-}

package/src/index.ts

@@ -1,2 +0,0 @@
-export { merge, mergeAndCompare, mergeAndConcat } from './merge'
-export { concatArrays } from './extensions'

package/src/merge.ts

@@ -1,102 +0,0 @@
-import { O } from 'ts-toolbelt'
-import { isPlainObject, isSymbol } from 'is-what'
-import { concatArrays } from './extensions'
-
-function assignProp(
-  carry: Record<string, any>,
-  key: string,
-  newVal: any,
-  originalObject: Record<string, any>
-): void {
-  const propType = {}.propertyIsEnumerable.call(originalObject, 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<
-  T1 extends Record<string, any> | any,
-  T2 extends Record<string, any> | any
->(
-  origin: T1,
-  newComer: T2,
-  compareFn?: (prop1: any, prop2: any, propName: string) => any
-): (T1 & T2) | T2 {
-  // always return newComer if its not an object
-  if (!isPlainObject(newComer)) return newComer
-  // define newObject to merge all values upon
-  let newObject = {} as (T1 & T2) | T2
-  if (isPlainObject(origin)) {
-    const props = Object.getOwnPropertyNames(origin)
-    const symbols = Object.getOwnPropertySymbols(origin)
-    newObject = [...props, ...symbols].reduce((carry, key) => {
-      const targetVal = origin[key as string]
-      if (
-        (!isSymbol(key) && !Object.getOwnPropertyNames(newComer).includes(key)) ||
-        (isSymbol(key) && !Object.getOwnPropertySymbols(newComer).includes(key))
-      ) {
-        assignProp(carry as Record<string, any>, key as string, targetVal, origin)
-      }
-      return carry
-    }, {} as (T1 & T2) | T2)
-  }
-  // newObject has all properties that newComer hasn't
-  const props = Object.getOwnPropertyNames(newComer)
-  const symbols = Object.getOwnPropertySymbols(newComer)
-  const result = [...props, ...symbols].reduce((carry, key) => {
-    // re-define the origin and newComer as targetVal and newVal
-    let newVal = newComer[key as string]
-    const targetVal = isPlainObject(origin) ? origin[key as string] : undefined
-    // When newVal is an object do the merge recursively
-    if (targetVal !== undefined && isPlainObject(newVal)) {
-      newVal = mergeRecursively(targetVal, newVal, compareFn)
-    }
-    const propToAssign = compareFn ? compareFn(targetVal, newVal, key as string) : newVal
-    assignProp(carry as Record<string, any>, key as string, propToAssign, 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 object
- * @param otherObjects
- */
-export function merge<T extends Record<string, any>, Tn extends Record<string, any>[]>(
-  object: T,
-  ...otherObjects: Tn
-): O.Assign<T, Tn, 'deep'> {
-  return otherObjects.reduce((result, newComer) => {
-    return mergeRecursively(result, newComer)
-  }, object) as any
-}
-
-export function mergeAndCompare<T extends Record<string, any>, Tn extends Record<string, any>[]>(
-  compareFn: (prop1: any, prop2: any, propName: string | symbol) => any,
-  object: T,
-  ...otherObjects: Tn
-): O.Assign<T, Tn, 'deep'> {
-  return otherObjects.reduce((result, newComer) => {
-    return mergeRecursively(result, newComer, compareFn)
-  }, object) as any
-}
-
-export function mergeAndConcat<T extends Record<string, any>, Tn extends Record<string, any>[]>(
-  object: T,
-  ...otherObjects: Tn
-): O.Assign<T, Tn, 'deep'> {
-  return otherObjects.reduce((result, newComer) => {
-    return mergeRecursively(result, newComer, concatArrays)
-  }, object) as any
-}

package/test/index.ts

@@ -1,299 +0,0 @@
-import test from 'ava'
-import { isDate } from 'is-what'
-import { merge } from '../src/index'
-
-function copy<T> (any: T): T {
-  return JSON.parse(JSON.stringify(any))
-}
-
-test('1. origin & target stays the same | 2. works with dates', t => {
-  const nd = new Date()
-  const origin = { body: 'a' }
-  const target = { dueDate: nd }
-  const res = merge(origin, target)
-  t.deepEqual(res, { body: 'a', dueDate: nd })
-  t.deepEqual(origin, { body: 'a' })
-  t.deepEqual(target, { dueDate: nd })
-})
-test('adding a prop on target1|target2|mergedObj', t => {
-  const origin = { nested: {} }
-  const target = { nested: {} }
-  const res = merge(origin, target)
-  t.deepEqual(res, { nested: {} })
-  const originAsAny: any = origin
-  const targetAsAny: any = target
-  const resAsAny: any = res
-  originAsAny.nested.a = ''
-  targetAsAny.nested.b = ''
-  resAsAny.nested.c = ''
-  t.deepEqual(originAsAny, { nested: { a: '' } })
-  t.deepEqual(targetAsAny, { nested: { b: '' } })
-  t.deepEqual(res, { nested: { c: '' } })
-})
-test('changing a prop on target1|target2|mergedObj: failing example', t => {
-  const origin = { nested: { a: 1 } }
-  const target = {}
-  const res = merge(origin, target)
-  t.deepEqual(res, { nested: { a: 1 } })
-  origin.nested.a = 2
-  t.deepEqual(origin, { nested: { a: 2 } }) // linked
-  t.deepEqual(target, {})
-  t.deepEqual(res, { nested: { a: 2 } }) // linked
-  const targetAsAny: any = target
-  targetAsAny.nested = { a: 3 }
-  t.deepEqual(origin, { nested: { a: 2 } }) // not changed
-  t.deepEqual(targetAsAny, { nested: { a: 3 } })
-  t.deepEqual(res, { nested: { a: 2 } }) // not changed
-  res.nested.a = 4
-  t.deepEqual(origin, { nested: { a: 4 } }) // linked
-  t.deepEqual(targetAsAny, { nested: { a: 3 } })
-  t.deepEqual(res, { nested: { a: 4 } }) // linked
-})
-test('changing a prop on target1|target2|mergedObj: working example', t => {
-  const origin = { nested: { a: 1 } }
-  const target = {}
-  const merged = merge(origin, target)
-  const res = copy(merged)
-  t.deepEqual(res, { nested: { a: 1 } })
-  origin.nested.a = 2
-  t.deepEqual(origin, { nested: { a: 2 } }) // not linked
-  t.deepEqual(target, {})
-  t.deepEqual(res, { nested: { a: 1 } }) // not linked
-  const targetAsAny: any = target
-  targetAsAny.nested = { a: 3 }
-  t.deepEqual(origin, { nested: { a: 2 } }) // not changed
-  t.deepEqual(targetAsAny, { nested: { a: 3 } })
-  t.deepEqual(res, { nested: { a: 1 } }) // not changed
-  res.nested.a = 4
-  t.deepEqual(origin, { nested: { a: 2 } }) // not linked
-  t.deepEqual(targetAsAny, { nested: { a: 3 } })
-  t.deepEqual(res, { nested: { a: 4 } }) // not linked
-})
-test('1. works with multiple levels | 2. overwrites entire object with null', t => {
-  const origin = { body: '', head: null, toes: { big: true }, fingers: { '12': false } }
-  const target = { body: {}, head: {}, toes: {}, fingers: null }
-  const res = merge(origin, target)
-  t.deepEqual(res, { body: {}, head: {}, toes: { big: true }, fingers: null })
-})
-test('origin and target are not AsAny', t => {
-  const origin = { body: '', head: null, toes: { big: true }, fingers: { '12': false } }
-  const target = { body: {}, head: {}, toes: {}, fingers: null }
-  const res = merge(origin, target)
-  t.deepEqual(res, { body: {}, head: {}, toes: { big: true }, fingers: null })
-  t.deepEqual(origin, { body: '', head: null, toes: { big: true }, fingers: { '12': false } })
-  t.deepEqual(target, { body: {}, head: {}, toes: {}, fingers: null })
-  origin.body = 'a'
-  const originAsAny: any = origin
-  const targetAsAny: any = target
-  originAsAny.head = 'a'
-  originAsAny.toes.big = 'a'
-  originAsAny.fingers['12'] = 'a'
-  targetAsAny.body = 'b'
-  targetAsAny.head = 'b'
-  targetAsAny.toes = 'b'
-  targetAsAny.fingers = 'b'
-  t.deepEqual(res, { body: {}, head: {}, toes: { big: true }, fingers: null })
-  t.deepEqual(originAsAny, { body: 'a', head: 'a', toes: { big: 'a' }, fingers: { '12': 'a' } })
-  t.deepEqual(targetAsAny, { body: 'b', head: 'b', toes: 'b', fingers: 'b' })
-})
-test('Overwrite arrays', t => {
-  const origin = { array: ['a'] }
-  const target = { array: ['b'] }
-  const res = merge(origin, target)
-  t.deepEqual(res, { array: ['b'] })
-})
-test('overwrites null with empty object', t => {
-  const origin = { body: null }
-  const target = { body: {} }
-  const res = merge(origin, target)
-  t.deepEqual(res, { body: {} })
-})
-test('overwrites null with object with props', t => {
-  const origin = { body: null }
-  const target = { body: { props: true } }
-  const res = merge(origin, target)
-  t.deepEqual(res, { body: { props: true } })
-})
-test('overwrites string values', t => {
-  const origin = { body: 'a' }
-  const target = { body: 'b' }
-  const res = merge(origin, target)
-  t.deepEqual(res, { body: 'b' })
-  t.deepEqual(origin, { body: 'a' })
-  t.deepEqual(target, { body: 'b' })
-})
-test('works with very deep props & dates', t => {
-  const newDate = new Date()
-  const origin = {
-    info: {
-      time: 'now',
-      newDate,
-      very: { deep: { prop: false } },
-    },
-  }
-  const target = {
-    info: {
-      date: 'tomorrow',
-      very: { deep: { prop: true } },
-    },
-  }
-  const res = merge(origin, target)
-  t.deepEqual(res, {
-    info: {
-      time: 'now',
-      newDate,
-      date: 'tomorrow',
-      very: { deep: { prop: true } },
-    },
-  })
-  t.deepEqual(origin, {
-    info: {
-      time: 'now',
-      newDate,
-      very: { deep: { prop: false } },
-    },
-  })
-  t.deepEqual(target, {
-    info: {
-      date: 'tomorrow',
-      very: { deep: { prop: true } },
-    },
-  })
-  t.true(isDate(res.info.newDate))
-})
-test('1. does not overwrite origin prop if target prop is an empty object | 2. properly merges deep props', t => {
-  const origin = {
-    info: {
-      time: { when: 'now' },
-      very: { deep: { prop: false } },
-    },
-  }
-  const target = {
-    info: {
-      time: {},
-      very: { whole: 1 },
-    },
-  }
-  const res = merge(origin, target)
-  t.deepEqual(res, {
-    info: {
-      time: { when: 'now' },
-      very: {
-        deep: { prop: false },
-        whole: 1,
-      },
-    },
-  })
-})
-test('overwrites any origin prop when target prop is an object with props', t => {
-  const origin = {
-    body: 'a',
-    body2: { head: false },
-    tail: {},
-  }
-  const target = {
-    body: { head: true },
-    body2: { head: { eyes: true } },
-  }
-  const res = merge(origin, target)
-  t.deepEqual(res, {
-    body: { head: true },
-    body2: { head: { eyes: true } },
-    tail: {},
-  })
-  t.deepEqual(origin, {
-    body: 'a',
-    body2: { head: false },
-    tail: {},
-  })
-  t.deepEqual(target, {
-    body: { head: true },
-    body2: { head: { eyes: true } },
-  })
-})
-
-test('works with unlimited depth', t => {
-  const date = new Date()
-  const origin = { origin: 'a', t2: false, t3: {}, t4: 'false' }
-  const t1 = { t1: date }
-  const t2 = { t2: 'new' }
-  const t3 = { t3: 'new' }
-  const t4 = { t4: 'new', t3: {} }
-  const res = merge(origin, t1, t2, t3, t4)
-  t.deepEqual(res, { origin: 'a', t1: date, t2: 'new', t3: {}, t4: 'new' })
-  t.deepEqual(origin, { origin: 'a', t2: false, t3: {}, t4: 'false' })
-  t.deepEqual(t1, { t1: date })
-  t.deepEqual(t2, { t2: 'new' })
-  t.deepEqual(t3, { t3: 'new' })
-  t.deepEqual(t4, { t4: 'new', t3: {} })
-})
-
-test('symbols as keys 1', t => {
-  const mySymbol = Symbol('mySymbol')
-  const x = { value: 42, [mySymbol]: 'hello' }
-  const y = { other: 33 }
-  const res = merge(x, y)
-  t.is(res.value, 42)
-  t.is(res.other, 33)
-  t.is(res[mySymbol], 'hello')
-})
-test('symbols as keys 2', t => {
-  const mySymbol = Symbol('mySymbol')
-  const x = { value: 42 }
-  const y = { other: 33, [mySymbol]: 'hello' }
-  const res = merge(x, y)
-  t.is(res.value, 42)
-  t.is(res.other, 33)
-  t.is(res[mySymbol], 'hello')
-})
-
-test('nonenumerable keys', t => {
-  const mySymbol = Symbol('mySymbol')
-  const x = { value: 42 }
-  const 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,
-  })
-  const res = merge(x, y)
-  t.is(res.value, 42)
-  t.is(res.other, 33)
-  t.is((res as any).xid, 1)
-  t.is((res as any).yid, 2)
-  t.is((res as any)[mySymbol], 'new')
-  t.is(Object.keys(res).length, 2)
-  t.true(Object.keys(res).includes('value'))
-  t.true(Object.keys(res).includes('other'))
-})
-
-test('readme', t => {
-  const starter = { name: 'Squirtle', types: { water: true } }
-  const newValues = { name: 'Wartortle', types: { fighting: true }, level: 16 }
-  const evolution = merge(starter, newValues, { is: 'cool' })
-  t.deepEqual(evolution, {
-    name: 'Wartortle',
-    types: { water: true, fighting: true },
-    level: 16,
-    is: 'cool',
-  })
-})

package/test/mergeAndCompare.ts

@@ -1,62 +0,0 @@
-import test from 'ava'
-import { isDate, isString, isArray, isObject } from 'is-what'
-import { mergeAndCompare } from '../src/index'
-
-test('conversion based on original val', t => {
-  function convertTimestamps (originVal: any, targetVal: any) {
-    if (originVal === '%convertTimestamp%' && isString(targetVal) && isDate(new Date(targetVal))) {
-      return new Date(targetVal)
-    }
-    return targetVal
-  }
-  const origin = {
-    date: '%convertTimestamp%',
-  }
-  const target = {
-    date: '1990-06-22',
-  }
-  const res = mergeAndCompare(convertTimestamps, origin, target)
-  t.deepEqual(res as any, { date: new Date('1990-06-22') })
-  // doesn't work on base lvl anymore
-  // const res2 = mergeAndCompare(convertTimestamps, '%convertTimestamp%', '1990-06-22')
-  // t.deepEqual(res2, new Date('1990-06-22'))
-})
-test('conversion based on prop key', t => {
-  function convertTimestamps (originVal: any, targetVal: any, key: any) {
-    if (isString(targetVal) && key === 'date') {
-      return new Date(targetVal)
-    }
-    return targetVal
-  }
-  const origin = {
-    date: '%convertTimestamp%',
-    a: {},
-  }
-  const target = {
-    date: '1990-06-22',
-    a: { date: '1990-01-01' },
-  }
-  const res = mergeAndCompare(convertTimestamps, origin, target)
-  t.deepEqual(res as any, { date: new Date('1990-06-22'), a: { date: new Date('1990-01-01') } })
-})
-test('Extend with custom concat arrays', t => {
-  function concatArr (originVal: any, targetVal: any) {
-    if (isArray(originVal) && isArray(targetVal)) {
-      return originVal.concat(targetVal)
-    }
-    return targetVal
-  }
-  const origin = {
-    someArray: ['a'],
-    a: { b: { c: ['x'] } },
-  }
-  const target = {
-    someArray: ['b'],
-    a: { b: { c: ['y'] } },
-  }
-  const res = mergeAndCompare(concatArr, origin, target)
-  t.deepEqual(res, { someArray: ['a', 'b'], a: { b: { c: ['x', 'y'] } } })
-  // doesn't work on base lvl anymore
-  // const res2 = mergeAndCompare(concatArr, ['a'], ['b'])
-  // t.deepEqual(res2, ['a', 'b'])
-})

package/test/mergeAndConcat.ts

@@ -1,15 +0,0 @@
-import test from 'ava'
-import { mergeAndConcat } from '../src/index'
-
-test('mergeAndConcat', t => {
-  const origin = {
-    someArray: ['a'],
-    a: { b: { c: ['x'] } },
-  }
-  const target = {
-    someArray: ['b'],
-    a: { b: { c: ['y'] } },
-  }
-  const res = mergeAndConcat(origin, target)
-  t.deepEqual(res, { someArray: ['a', 'b'], a: { b: { c: ['x', 'y'] } } })
-})

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "compilerOptions": {
-    "baseUrl": ".",
-    "lib": ["ES2015", "ES2016", "ES2017", "ES2018", "ES2019", "ES2020"],
-    "strict": true,
-    "isolatedModules": true,
-    "esModuleInterop": true,
-    "moduleResolution": "node",
-    "declaration": true,
-    "declarationDir": "./types/"
-  },
-  "include": [
-    "src/**/*",
-    "test/**/*"
-  ]
-}