merge-anything 3.0.7 → 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
 ```
@@ -35,7 +38,9 @@ merge-anything will merge objects and nested properties, but only as long as the
 
 ## Usage
 
-Pass the base param first and then an unlimited amount of params to merge onto it.
+- Unlimited — Merge will merge an unlimited amount of plain objects you pass as the arguments
+- Nested — Nested objects are merged deeply (see example below)
+- No modification — Merge always returns a new object without modifying the original, but does keep object/array references for nested props (see [#A note on JavaScript object references](#a-note-on-javascript-object-references))
 
 ```js
 import { merge } from 'merge-anything'
@@ -68,11 +73,13 @@ This package will recursively go through plain objects and merge the values onto
 // all passed objects do not get modified
 const a = { a: 'a' }
 const b = { b: 'b' }
-const c = merge(a, b)
+const c = { c: 'c' }
+const result = merge(a, b, c)
 // a === {a: 'a'}
 // b === {b: 'b'}
-// c === {a: 'a', b: 'b'}
-// However, be careful with JavaScript object references. See below: A note on JavaScript object references
+// c === {c: 'c'}
+// result === {a: 'a', b: 'b', c: 'c'}
+// However, be careful with JavaScript object references with nested props. See below: A note on JavaScript object references
 
 // arrays get overwritten
 // (for "concat" logic, see Extensions below)
@@ -83,7 +90,6 @@ merge({ obj: { prop: 'a' } }, { obj: {} }) // returns {obj: {prop: 'a'}}
 
 // but non-objects overwrite objects
 merge({ obj: { prop: 'a' } }, { obj: null }) // returns {obj: null}
-merge({ obj: 'a' }, 'b') // returns 'b'
 
 // and empty objects overwrite non-objects
 merge({ prop: 'a' }, { prop: {} }) // returns {prop: {}}
@@ -91,7 +97,7 @@ merge({ prop: 'a' }, { prop: {} }) // returns {prop: {}}
 
 merge-anything properly keeps special objects intact like dates, regex, functions, class instances etc.
 
-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.
+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.
 
 ## Concat arrays
 
@@ -113,9 +119,11 @@ mergeAndConcat(
 
 There might be times you need to tweak the logic when two things are merged. You can provide your own custom function that's triggered every time a value is overwritten.
 
-Here is an example with a compare function that concatenates strings:
+For this case we use `mergeAndCompare`. Here is an example with a compare function that concatenates strings:
 
 ```js
+import { mergeAndCompare } from 'merge-anything'
+
 function concatStrings (originVal, newVal, key) {
   if (typeof originVal === 'string' && typeof newVal === 'string') {
     // concat logic
@@ -136,18 +144,18 @@ mergeAndCompare(concatStrings, { name: 'John' }, { name: 'Simth' })
 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: 'dep. 🛫' } }
+const original = { airport: { status: 'dep. 🛫' } }
 const extraInfo = { airport: { location: 'Brussels' } }
 const merged = merge(original, extraInfo)
 
-// we change the airplane from departuring 🛫 to landing 🛬
-merged.airport.airplane = 'lan. 🛬'
+// we change the status from departuring 🛫 to landing 🛬
+merged.airport.status = 'lan. 🛬'
 
 // the `merged` value will be modified
-// merged.airport.airplane === 'lan. 🛬'
+// merged.airport.status === 'lan. 🛬'
 
 // However `original` value will also be modified!!
-// original.airport.airplane === 'lan. 🛬'
+// original.airport.status === 'lan. 🛬'
 ```
 
 The key rule to remember is:
@@ -161,15 +169,15 @@ See below how we integrate 'copy-anything':
 ```js
 import copy from 'copy-anything'
 
-const original = { airport: { airplane: 'dep. 🛫' } }
+const original = { airport: { status: 'dep. 🛫' } }
 const extraInfo = { airport: { location: 'Brussels' } }
 const merged = copy(merge(original, extraInfo))
 
-// we change the airplane from departuring 🛫 to landing 🛬
-merged.airport.airplane = 'lan. 🛬'(merged.airport.airplane === 'lan. 🛬')(
+// we change the status from departuring 🛫 to landing 🛬
+merged.airport.status = 'lan. 🛬'(merged.airport.status === 'lan. 🛬')(
   // true
   // `original` won't be modified!
-  original.airport.airplane === 'dep. 🛫'
+  original.airport.status === 'dep. 🛫'
 ) // true
 ```
 

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/dist/types/merge.d.ts

@@ -0,0 +1,11 @@
+import { O } from 'ts-toolbelt';
+/**
+ * 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 declare function merge<T extends Record<string, any>, Tn extends Record<string, any>[]>(object: T, ...otherObjects: Tn): O.Assign<T, Tn, 'deep'>;
+export declare 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'>;
+export declare function mergeAndConcat<T extends Record<string, any>, Tn extends Record<string, any>[]>(object: T, ...otherObjects: Tn): O.Assign<T, Tn, 'deep'>;

package/package.json

@@ -1,16 +1,31 @@
 {
   "name": "merge-anything",
-  "version": "3.0.7",
+  "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",
-  "typings": "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 lint && npm run test && npm run rollup"
+    "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",
@@ -39,33 +54,59 @@
     "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.7.1",
-    "ts-toolbelt": "^6.3.6"
+    "is-what": "^4.1.1",
+    "ts-toolbelt": "^9.6.0"
   },
   "devDependencies": {
-    "@typescript-eslint/eslint-plugin": "^2.23.0",
-    "@typescript-eslint/parser": "^2.23.0",
-    "ava": "^3.5.0",
-    "eslint": "^6.8.0",
-    "eslint-config-prettier": "^6.10.0",
-    "eslint-plugin-tree-shaking": "^1.8.0",
-    "rollup": "^1.32.1",
-    "rollup-plugin-typescript2": "^0.26.0",
-    "ts-node": "^8.6.2",
-    "typescript": "^3.8.3"
+    "@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.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"
   },
-  "ava": {
-    "extensions": [
-      "ts"
+  "np": {
+    "yarn": false,
+    "branch": "production"
+  },
+  "eslintConfig": {
+    "ignorePatterns": [
+      "node_modules",
+      "dist",
+      "scripts",
+      "test"
+    ],
+    "root": true,
+    "parser": "@typescript-eslint/parser",
+    "plugins": [
+      "@typescript-eslint",
+      "tree-shaking"
+    ],
+    "extends": [
+      "eslint:recommended",
+      "plugin:@typescript-eslint/eslint-recommended",
+      "plugin:@typescript-eslint/recommended",
+      "prettier"
     ],
-    "require": [
-      "ts-node/register"
-    ]
+    "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",
+      "@typescript-eslint/ban-ts-comment": "off"
+    }
   }
 }

package/.eslintignore

@@ -1,8 +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

package/.eslintrc.js

@@ -1,17 +0,0 @@
-// npm i -D @typescript-eslint/eslint-plugin @typescript-eslint/parser eslint eslint-config-prettier eslint-plugin-tree-shaking
-module.exports = {
-  root: true,
-  parser: '@typescript-eslint/parser',
-  plugins: ['@typescript-eslint', 'tree-shaking'],
-  extends: [
-    'eslint:recommended',
-    'plugin:@typescript-eslint/eslint-recommended',
-    'plugin:@typescript-eslint/recommended',
-    'prettier/@typescript-eslint'
-  ],
-  rules: {
-    '@typescript-eslint/no-explicit-any': 'off',
-    '@typescript-eslint/ban-ts-ignore': 'off',
-    'tree-shaking/no-side-effects-in-initialization': 'error'
-  }
-}

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/_playground.ts

@@ -1,27 +0,0 @@
-import { OptionalDeep } from 'Object/Optional'
-import {O} from 'ts-toolbelt'
-
-type merge = O.Assign<
-	{ obj: string, num: number, nested: { values: number[] } },
-	[{ obj: Record<string, any> }]
->
-
-interface MyObject { someVal: string }
-interface MyType { array?: MyObject[] }
-
-const defaults: MyType = {
-	array: []
-}
-
-type Merged = O.Assign<typeof defaults, [OptionalDeep<MyType>], "deep">
-
-
-interface GoogleStudent {
-	googleUserId: string
-}
-interface Test {
-	googleStudents?: GoogleStudent[]
-}
-
-type N = O.Assign<Test, [O.Partial<Test, "deep">], "deep">
-

package/build/rollup.js

@@ -1,55 +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 })]
-
-// ------------------------------------------------------------------------------------------
-// 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' },
-    ],
-  }),
-]