Prevent mutable structures when merging Immutable objects

__tests__/issues.ts

@@ -1,4 +1,13 @@
-import { List, OrderedMap, OrderedSet, Record, Seq, Set } from 'immutable';
+import {
+  fromJS,
+  List,
+  Map,
+  OrderedMap,
+  OrderedSet,
+  Record,
+  Seq,
+  Set,
+} from 'immutable';
 
 describe('Issue #1175', () => {
   it('invalid hashCode() response should not infinitly recurse', () => {
@@ -121,3 +130,31 @@ describe('Issue #1785', () => {
 
   expect(emptyRecord.merge({ id: 1 })).toBe(emptyRecord);
 });
+
+describe('Issue #1475', () => {
+  it('complex case should return first value on mergeDeep when types are incompatible', () => {
+    const a = fromJS({
+      ch: [
+        {
+          code: 8,
+        },
+      ],
+    }) as Map<unknown, unknown>;
+    const b = fromJS({
+      ch: {
+        code: 8,
+      },
+    });
+    expect(a.mergeDeep(b).equals(b)).toBe(true);
+  });
+
+  it('simple case should return first value on mergeDeep when types are incompatible', () => {
+    const a = fromJS({
+      ch: [],
+    }) as Map<unknown, unknown>;
+    const b = fromJS({
+      ch: { code: 8 },
+    });
+    expect(a.mergeDeep(b).equals(b)).toBe(true);
+  });
+});

src/functional/merge.js

@@ -1,7 +1,10 @@
 import { isImmutable } from '../predicates/isImmutable';
+import { isIndexed } from '../predicates/isIndexed';
+import { isKeyed } from '../predicates/isKeyed';
 import { IndexedCollection, KeyedCollection } from '../Collection';
 import hasOwnProperty from '../utils/hasOwnProperty';
 import isDataStructure from '../utils/isDataStructure';
+import isPlainObject from '../utils/isPlainObj';
 import shallowCopy from '../utils/shallowCopy';
 
 export function merge(collection, ...sources) {
@@ -69,10 +72,19 @@ export function mergeWithSources(collection, sources, merger) {
 function deepMergerWith(merger) {
   function deepMerger(oldValue, newValue, key) {
     return isDataStructure(oldValue) && isDataStructure(newValue)
-      ? mergeWithSources(oldValue, [newValue], deepMerger)
+      ? areMergeable(oldValue, newValue)
+        ? mergeWithSources(oldValue, [newValue], deepMerger)
+        : newValue
       : merger
       ? merger(oldValue, newValue, key)
       : newValue;
   }
   return deepMerger;
 }
+
+function areMergeable(oldValue, newValue) {
+  return !(
+    (isIndexed(oldValue) || Array.isArray(oldValue)) &&
+    (isKeyed(newValue) || isPlainObject(newValue))
+  );
+}