assign({ a: [1] }, { a: [2] }); // => { a: [2] }

I was expecting a to be the combination of both arrays, but instead it is the value of the latter object.

Hello! Thanks for the useful library.

Recently I've noticed that it does mutate Dates:

var assignDeep = require("assign-deep");

const a = {
    date: new Date(),
    anyObj: {}
};

const b = assignDeep({}, a);

console.log(
    a.anyObj === b.anyObj, // Gives false as expected.
    a.date === b.date // Gives true. Should it be false?
); 

My idea is that date objects must not be mutated as well as any other objects. Not to be unfounded, a.date.setTime(X) will change both a.date and b.date in the example above. What do you think? I can process with the pull request if you agree.

Thank you!

A changelog would be useful either as a file in the repo or as notes in the releases section of github.

For example I can't tell what has changed between 0.4.7 and 1.0.0 and if I should upgrade. What has changed in the 1.0.0 release, any breaking changes or differences in how it works?

Using Object.assign with an empty target, only the target is changed, not the inputs/arguments. Usign assign-deep, the inputs also get overwritten. Is this expected behaviour? I did not expect this.

var assignDeep = require("assign-deep")

var o1 = { a: 1, b: 1, c: {a: 1} };
var o2 = { b: 2, c: {a:2} };
var o3 = { c: {a:3} };

console.log(assignDeep({}, o1, o2, o3));
// Expected output: Object {a: 1, b: 2, c: Object {a: 3}}
console.log('o1', o1);
// Expected output: Object {a: 1, b: 1, c: Object {a: 1}}
// Actual output: Object {a: 1, b: 1, c: Object {a: 3}}

Practical application is a local configuration loading the default configuration if it is doesn't exist (if it is deeper). In the local configuration, I was to stop it from loading the deeper default configuration. Is this possible?

For example:
var local = a: { b: false };
var default = a: { b: { c: { d, e}}}, x: { y, z};
console.log(assign(local, default));

desire result is a {b: false}, x: {y, z}

I have some function definitions specified in objects and would like them to get overridden when objects are being combined using assign-deep, but it seems to work for all object keys except those referring to function definitions.

a = {
  string: 'a'
  func: a => a,
}
b = {
  string: 'b'
  func: b => b,
}
c = assignDeep({}, a, b)

console.log(c.string) // prints 'b' as expected
console.log(c.func.toString()) // prints 'a => a', not as expected

for example:

var assign = require('assign-deep');

var res1 = assign({}, {b: {c: 1}});

var res2 = Object.assign({}, {b: {c: 1}});

console.log(res1); //{}
console.log(res2); //{b:{c:1}}

is this a bug?

When using webpack to package the files, libraries, it converts every require to a function.
So,

var lazy = require('lazy-cache')(require);
lazy('is-extendable', 'isObject');

is converted to

var lazy = __webpack_require__(385)(__webpack_require__(386));

where it says no arguments passed to the last require and hence breaks with an error

"lazy-cache Cannot find module 'is-extandable' ./index.js"

I'm not sure if this is the fault of assign-deep or create-react-app, but upgrading assign-deep from 0.4.7 to 1.0.0 broke my build. I didn't upgrade for any reason other than there being a new version available. I have reverted back.

Reproduction (on Windows):

• Have create-react-app available (I'm using v1.1.4).
• Run commands:

  create-react-app assign-deep-test
  cd assign-deep-test
  yarn add [email protected]
  

• Edit assign-deep-test\src\App.js to have import assign from 'assign-deep';.
• Run command:

  yarn build
  

And this error appears:

$ react-scripts build
Creating an optimized production build...
Failed to compile.

Failed to minify the code from this file:

        ./node_modules/assign-deep/index.js:12

Read more here: http://bit.ly/2tRViJ9

error Command failed with exit code 1.
info Visit https://yarnpkg.com/en/docs/cli/run for documentation about this command.

In my actual project (uses code splitting), I get a different error:

Failed to compile.

Failed to minify the bundle. Error: static/js/main.2adb6dc3.js from UglifyJs
Unexpected token: punc (.) [static/js/main.2adb6dc3.js:139360,41]

v1.0.1 is a patch release to prevent unsafe properties from being assigned. See this guide if you need more assistance.

I've just decided to use this cool lib. I found some similar libs and I think this one is better but there's one small point - type definitions.

Can you add jsDoc comment to the function, or add this lib to https://definitelytyped.org/?
If you do that, your lib will be the best.

Would it make sense for assign-deep to throw an error when a string or number is passed?

const element = 'string'
console.log(assignDeep({a: 1}, element, {b: 2, a: 999}))

This prints { a: 999, b: 2 }, as expected. But for someone who passed in the string, it's almost certainly an error in their code because they wouldn't be passing a string or number in the first place. It would be helpful to get an error right away.

I've tested a few use cases against assign-deep and another project of yours mixin-deep, and they both seem to do what I want.

• Recursive
• Don't merge arrays but overwrites them with the last array found for a property
• Overwrite keys with null and undefined rather than ignoring them
• Don't make any changes to object1 and object2 when an empty object {} passed as first argument (e.g. assign({}, object1, object2) and mixin({}, object1, object2))

How are these 2 projects different, can you give some use cases with inputs that produce different outputs? Just want to make sure I'm using the right package for when I have to deal with more complex object structures where things may behave differently.