Allow nested propsdiffs for plain objects only

Author: wooorm

index.js

@@ -4,6 +4,8 @@ var array = require('x-is-array');
 var object = require('is-object');
 var proto = require('getprototypeof');
 
+var objectProto = Object.prototype;
+
 var ignoredKeys = ['type', 'children', 'value'];
 
 module.exports = diff;
@@ -112,17 +114,17 @@ function diffObjects(left, right) {
       continue;
     }
 
-    if (object(leftValue) && object(rightValue)) {
-      if (proto(rightValue) === proto(leftValue)) {
-        objectDiff = diffObjects(leftValue, rightValue);
+    if (
+      object(leftValue) &&
+      object(rightValue) &&
+      proto(rightValue) === objectProto &&
+      proto(leftValue) === objectProto
+    ) {
+      objectDiff = diffObjects(leftValue, rightValue);
 
-        if (objectDiff) {
-          diff = diff || {};
-          diff[leftKey] = objectDiff;
-        }
-      } else {
+      if (objectDiff) {
         diff = diff || {};
-        diff[leftKey] = rightValue;
+        diff[leftKey] = objectDiff;
       }
     } else {
       diff = diff || {};

readme.md

@@ -157,8 +157,7 @@ Patches represent changes.  They come with three properties:
 In the diff:
 
 *   If a key is removed, the key’s value is set to `undefined`.
-*   If the new value is of the same non-primitive type as the new value
-    (their prototype’s are equal, thus both array or both object), the key’s
+*   If the new value and the old value are both plain objects, the key’s
     value is set to a `PropsDiff` of both values.
 *   In all other cases, the key’s value is set to the new value.
 

test.js

@@ -86,18 +86,6 @@ test('unist-diff', function (t) {
       );
     })();
 
-    (function () {
-      var alpha = {type: 'alpha'};
-      var left = {type: 'bravo', charlie: [1, 2, 3], children: [alpha]};
-      var right = {type: 'bravo', charlie: [1, 2, 3], children: [alpha]};
-
-      st.deepEqual(
-        diff(left, right),
-        {left: left},
-        'should not return a patch for deep equal arrays'
-      );
-    })();
-
     (function () {
       var alpha = {type: 'alpha'};
       var left = {type: 'bravo', data: {charlie: 'delta', echo: true, foxtrot: 1, golf: null}, children: [alpha]};
@@ -167,6 +155,25 @@ test('unist-diff', function (t) {
       );
     })();
 
+    (function () {
+      var alpha = {type: 'alpha'};
+      var left = {type: 'bravo', charlie: [1, 2, 3], children: [alpha]};
+      var right = {type: 'bravo', charlie: [1, 2, 3], children: [alpha]};
+
+      st.deepEqual(
+        diff(left, right),
+        {
+          0: {
+            type: 'props',
+            left: left,
+            right: {charlie: [1, 2, 3]}
+          },
+          left: left
+        },
+        'should return a patch for deep equal arrays'
+      );
+    })();
+
     (function () {
       var alpha = {type: 'alpha'};
       var left = {type: 'bravo', charlie: [1, 2, 3], children: [alpha]};