Add updatededDiff function to find only changed difference in lhs/ rhs

Author: mattphillips

src/updated/index.js

@@ -0,0 +1,23 @@
+import { isEmpty, isObject } from '../utils';
+
+const updatedDiff = (lhs, rhs) => {
+
+  if (lhs === rhs) return {};
+
+  if (!isObject(lhs) || !isObject(rhs)) return rhs;
+
+  return Object.keys(rhs).reduce((acc, key) => {
+
+    if (lhs.hasOwnProperty(key)) {
+      const difference = updatedDiff(lhs[key], rhs[key]);
+
+      if (isObject(difference) && isEmpty(difference)) return acc;
+
+      return { ...acc, [key]: difference };
+    }
+
+    return acc;
+  }, {});
+};
+
+export default updatedDiff;

src/updated/index.spec.js

@@ -0,0 +1,92 @@
+import { expect } from 'chai';
+import forEach from 'mocha-each';
+
+import updatedDiff from './';
+
+describe('.updatedDiff', () => {
+
+  describe('base case', () => {
+    describe('equal', () => {
+      forEach([
+        ['int', 1],
+        ['string', 'a'],
+        ['boolean', true],
+        ['null', null],
+        ['undefined', undefined],
+        ['object', { a: 1 }],
+        ['array', [1]],
+        ['function', () => ({})],
+      ]).it('returns empty object when given values of type %s are equal', (type, value) => {
+        expect(updatedDiff(value, value)).to.deep.equal({});
+      });
+    });
+
+    describe('not equal and not object', () => {
+      forEach([
+        [1, 2],
+        ['a', 'b'],
+        [true, false],
+        ['hello', null],
+        ['hello', undefined],
+        [null, undefined],
+        [undefined, null],
+        [null, { a: 1 }],
+        ['872983', { areaCode: '+44', number: '872983' }],
+        [100, () => ({})],
+        [() => ({}), 100],
+      ]).it('returns right hand side value when different to left hand side value (%s, %s)', (lhs, rhs) => {
+        expect(updatedDiff(lhs, rhs)).to.deep.equal(rhs);
+      });
+    });
+  });
+
+  describe('recursive case', () => {
+    describe('object', () => {
+      it('returns right hand side value when given objects are different at root', () => {
+        expect(updatedDiff({ a: 1 }, { a: 2 })).to.deep.equal({ a: 2 });
+      });
+
+      it('returns right hand side value when right hand side value is null', () => {
+        expect(updatedDiff({ a: 1 }, { a: null })).to.deep.equal({ a: null });
+      });
+
+      it('returns subset of right hand side value when sibling objects differ', () => {
+        expect(updatedDiff({ a: { b: 1 }, c: 2 }, { a: { b: 1 }, c: 3 })).to.deep.equal({ c: 3 });
+      });
+
+      it('returns subset of right hand side value when nested values differ', () => {
+        expect(updatedDiff({ a: { b: 1, c: 2} }, { a: { b: 1, c: 3 } })).to.deep.equal({ a: { c: 3 } });
+      });
+
+      it('returns subset of right hand side value when nested values differ at multiple paths', () => {
+        expect(updatedDiff({ a: { b: 1 }, c: 2, d: { e: 100 } }, { a: { b: 99 }, c: 3, d: { e: 100 } })).to.deep.equal({ a: { b: 99 }, c: 3 });
+      });
+
+      it('returns empty object when deleted from right hand side', () => {
+        expect(updatedDiff({ a: 1, b: { c: 2 }}, { a: 1 })).to.deep.equal({});
+      });
+
+      it('returns empty object when a key value has been added', () => {
+        expect(updatedDiff({ a: 1 }, { a: 1, b: 2 })).to.deep.equal({});
+      });
+    });
+
+    describe('arrays', () => {
+      it('returns right hand side value as object of indices to value when arrays are different', () => {
+        expect(updatedDiff([1], [2])).to.deep.equal({ 0: 2 });
+      });
+
+      it('returns subset of right hand side array as object of indices to value when arrays differs at multiple indicies', () => {
+        expect(updatedDiff([1, 2, 3], [9, 8, 3])).to.deep.equal({ 0: 9, 1: 8 });
+      });
+
+      it('returns subset of right hand side array as object of indices to value when right hand side array has deletions', () => {
+        expect(updatedDiff([1, 2, 3], [1, 3])).to.deep.equal({ 1: 3 });
+      });
+
+      it('returns empty object when right hand side array has additions', () => {
+        expect(updatedDiff([1, 2, 3], [1, 2, 3, 9])).to.deep.equal({});
+      });
+    });
+  });
+});