For values returned from diff(), null === {}

The code responsible for this is in vm.diff.cmp. And it is executed during redrawSync().

Small test:

// Dummy vm for testing:
var vm = domvm.createView({render: function() {}});
vm.config({diff: function() {return 0;}});

// The comparison function that compares successive values returned by diff()
// doesn't differentiate between null and {}:
console.log("null === {}:", vm.diff.cmp(vm, null, {}));      // => false
console.log("null === null:", vm.diff.cmp(vm, null, null));  // => false

// It is actually the same problem for any primitive value:
console.log("12 === 34:", vm.diff.cmp(vm, 12, 34));    // => false
console.log("12 === 12:", vm.diff.cmp(vm, 12, 12));    // => false

[jlgrall]

Well there is still a problem with eq(). For example:

eq({}, null);  // => true
eq({}, 1);  // => true

This may happen because if one time you compare the old value null and the new value {}, the next time {} will be your old value, so the situation might be reversed.

Here is a possible solution:

function eq2(o, n) {
    return o === n || (
        typeof o === typeof n && n !== null && (
            isArr(o) ? eqArr(o, n) :
            isPlainObj(o) ? eqObj(o, n) :
            false
        )
    );
}

The idea is that if o and n are not the same type, we return false. We need to take care of the special case where either o or n is null. But we can actually skip the o !== null because that will fallthrough the following tests and return false.

[leeoniya]

Do you really want to exclude all objects that are not plain

kinda. for example, things like new Date and new Promise dont produce objects that are easily discernable without explicit checks, yet dont make sense to pass through cmpObj. also, cmpObj would iterate an instance’s public methods, etc.

worst case for this “breaking” change is a perf regression, so i’m not too concerned.