Support diffing keys named like Object.prototype properties

.eslintrc.json

@@ -0,0 +1,15 @@
+{
+    "env": {
+        "browser": true,
+        "es2021": true,
+        "node": true,
+        "jest": true
+    },
+    "extends": "eslint:recommended",
+    "parserOptions": {
+        "ecmaVersion": 12,
+        "sourceType": "module"
+    },
+    "rules": {
+    }
+}

package.json

@@ -15,7 +15,8 @@
     "test": "jest",
     "test:coverage": "yarn test -- --coverage",
     "test:report": "cat ./coverage/lcov.info | ./node_modules/.bin/coveralls",
-    "test:watch": "yarn test -- --watch"
+    "test:watch": "yarn test -- --watch",
+    "posttest": "eslint src/"
   },
   "author": "Matt Phillips",
   "license": "MIT",
@@ -30,6 +31,7 @@
     "babel-preset-es2015": "^6.18.0",
     "babel-preset-stage-0": "^6.16.0",
     "coveralls": "^3.0.0",
+    "eslint": "^7.10.0",
     "jest": "^23.6.0"
   },
   "babel": {

src/added/index.js

@@ -1,14 +1,14 @@
-import { isEmpty, isObject, properObject } from '../utils';
+import { isEmpty, isObject, hasOwnProperty } from '../utils';
 
 const addedDiff = (lhs, rhs) => {
 
   if (lhs === rhs || !isObject(lhs) || !isObject(rhs)) return {};
 
-  const l = properObject(lhs);
-  const r = properObject(rhs);
+  const l = lhs;
+  const r = rhs;
 
   return Object.keys(r).reduce((acc, key) => {
-    if (l.hasOwnProperty(key)) {
+    if (hasOwnProperty(l, key)) {
       const difference = addedDiff(l[key], r[key]);
 
       if (isObject(difference) && isEmpty(difference)) return acc;

src/added/index.test.js

@@ -105,5 +105,13 @@ describe('.addedDiff', () => {
         expect(addedDiff(lhs, rhs)).toEqual({ date: new Date('2016') });
       });
     });
+
+    describe('object with non-function hasOwnProperty property', () => {
+      test('can represent the property in diff despite it being part of Object.prototype', () => {
+        const lhs = {};
+        const rhs = { hasOwnProperty: true };
+        expect(addedDiff(lhs, rhs)).toEqual({ hasOwnProperty: true });
+      });
+    });
   });
 });

src/arrayDiff/index.js

@@ -1,15 +1,15 @@
-import { isDate, isEmpty, isObject, properObject } from '../utils';
+import { isDate, isEmpty, isObject, hasOwnProperty } from '../utils';
 
 const diff = (lhs, rhs) => {
   if (lhs === rhs) return {}; // equal return no diff
 
   if (!isObject(lhs) || !isObject(rhs)) return rhs; // return updated rhs
 
-  const l = properObject(lhs);
-  const r = properObject(rhs);
+  const l = lhs;
+  const r = rhs;
 
   const deletedValues = Object.keys(l).reduce((acc, key) => {
-    return r.hasOwnProperty(key) ? acc : { ...acc, [key]: undefined };
+    return hasOwnProperty(r, key) ? acc : { ...acc, [key]: undefined };
   }, {});
 
   if (isDate(l) || isDate(r)) {
@@ -19,11 +19,11 @@ const diff = (lhs, rhs) => {
 
   if (Array.isArray(r) && Array.isArray(l)) {
     const deletedValues = l.reduce((acc, item, index) => {
-      return r.hasOwnProperty(index) ? acc.concat(item) : acc.concat(undefined);
+      return hasOwnProperty(r, index) ? acc.concat(item) : acc.concat(undefined);
     }, []);
 
     return r.reduce((acc, rightItem, index) => {
-      if (!deletedValues.hasOwnProperty(index)) {
+      if (!hasOwnProperty(deletedValues, index)) {
         return acc.concat(rightItem);
       }
 
@@ -40,7 +40,7 @@ const diff = (lhs, rhs) => {
   }
 
   return Object.keys(r).reduce((acc, key) => {
-    if (!l.hasOwnProperty(key)) return { ...acc, [key]: r[key] }; // return added r key
+    if (!hasOwnProperty(l, key)) return { ...acc, [key]: r[key] }; // return added r key
 
     const difference = diff(l[key], r[key]);
 

src/deleted/index.js

@@ -1,13 +1,13 @@
-import { isEmpty, isObject, properObject } from '../utils';
+import { isEmpty, isObject, hasOwnProperty } from '../utils';
 
 const deletedDiff = (lhs, rhs) => {
   if (lhs === rhs || !isObject(lhs) || !isObject(rhs)) return {};
 
-  const l = properObject(lhs);
-  const r = properObject(rhs);
+  const l = lhs;
+  const r = rhs;
 
   return Object.keys(l).reduce((acc, key) => {
-    if (r.hasOwnProperty(key)) {
+    if (hasOwnProperty(r, key)) {
       const difference = deletedDiff(l[key], r[key]);
 
       if (isObject(difference) && isEmpty(difference)) return acc;

src/deleted/index.test.js

@@ -107,5 +107,13 @@ describe('.deletedDiff', () => {
         expect(deletedDiff({ date: new Date('2016') }, rhs)).toEqual({ date: undefined });
       });
     });
+
+    describe('object with non-function hasOwnProperty property', () => {
+      test('can represent the property in diff despite it being part of Object.prototype', () => {
+        const lhs = { hasOwnProperty: true };
+        const rhs = {};
+        expect(deletedDiff(lhs, rhs)).toEqual({ hasOwnProperty: undefined });
+      });
+    });
   });
 });

src/diff/index.js

@@ -1,15 +1,15 @@
-import { isDate, isEmptyObject, isObject, properObject } from "../utils";
+import { isDate, isEmptyObject, isObject, hasOwnProperty } from '../utils';
 
 const diff = (lhs, rhs) => {
   if (lhs === rhs) return {}; // equal return no diff
 
   if (!isObject(lhs) || !isObject(rhs)) return rhs; // return updated rhs
 
-  const l = properObject(lhs);
-  const r = properObject(rhs);
+  const l = lhs;
+  const r = rhs;
 
   const deletedValues = Object.keys(l).reduce((acc, key) => {
-    return r.hasOwnProperty(key) ? acc : { ...acc, [key]: undefined };
+    return hasOwnProperty(r, key) ? acc : { ...acc, [key]: undefined };
   }, {});
 
   if (isDate(l) || isDate(r)) {
@@ -18,7 +18,7 @@ const diff = (lhs, rhs) => {
   }
 
   return Object.keys(r).reduce((acc, key) => {
-    if (!l.hasOwnProperty(key)) return { ...acc, [key]: r[key] }; // return added r key
+    if (!hasOwnProperty(l, key)) return { ...acc, [key]: r[key] }; // return added r key
 
     const difference = diff(l[key], r[key]);
 

src/preserveArray.js

@@ -1,4 +1,4 @@
-import { isObject } from './utils';
+import { isObject, hasOwnProperty } from './utils';
 
 const getLargerArray = (l, r) => l.length > r.length ? l : r;
 
@@ -16,7 +16,7 @@ const preserve = (diff, left, right) => {
       return {
         ...acc,
         [key]: array.reduce((acc2, item, index) => {
-          if (diff[key].hasOwnProperty(index)) {
+          if (hasOwnProperty(diff[key], index)) {
             acc2[index] = preserve(diff[key][index], leftArray[index], rightArray[index]); // diff recurse and check for nested arrays
             return acc2;
           }

src/updated/index.js

@@ -1,20 +1,20 @@
-import { isDate, isEmptyObject, isObject, properObject } from "../utils";
+import { isDate, isEmptyObject, isObject, hasOwnProperty } from '../utils';
 
 const updatedDiff = (lhs, rhs) => {
   if (lhs === rhs) return {};
 
   if (!isObject(lhs) || !isObject(rhs)) return rhs;
 
-  const l = properObject(lhs);
-  const r = properObject(rhs);
+  const l = lhs;
+  const r = rhs;
 
   if (isDate(l) || isDate(r)) {
     if (l.valueOf() == r.valueOf()) return {};
     return r;
   }
 
   return Object.keys(r).reduce((acc, key) => {
-    if (l.hasOwnProperty(key)) {
+    if (hasOwnProperty(l, key)) {
       const difference = updatedDiff(l[key], r[key]);
 
       // If the difference is empty, and the lhs is an empty object or the rhs is not an empty object

src/updated/index.test.js

@@ -147,5 +147,13 @@ describe('.updatedDiff', () => {
         expect(updatedDiff(lhs, rhs)).toEqual({ date: new Date('2017') });
       });
     });
+
+    describe('object with non-function hasOwnProperty property', () => {
+      test('can represent the property in diff despite it being part of Object.prototype', () => {
+        const lhs = { hasOwnProperty: false };
+        const rhs = { hasOwnProperty: true };
+        expect(updatedDiff(lhs, rhs)).toEqual({ hasOwnProperty: true });
+      });
+    });
   });
 });

src/utils/index.js

@@ -1,5 +1,5 @@
-export const isDate = (d) => d instanceof Date;
-export const isEmpty = (o) => Object.keys(o).length === 0;
-export const isObject = (o) => o != null && typeof o === "object";
-export const properObject = (o) => (isObject(o) && !o.hasOwnProperty ? { ...o } : o);
+export const isDate = d => d instanceof Date;
+export const isEmpty = o => Object.keys(o).length === 0;
+export const isObject = o => o != null && typeof o === 'object';
+export const hasOwnProperty = (o, ...args) => Object.prototype.hasOwnProperty.call(o, ...args)
 export const isEmptyObject = (o) => isObject(o) && isEmpty(o);

src/utils/index.test.js

@@ -1,4 +1,4 @@
-import { isDate, isEmpty, isObject, properObject } from './';
+import { isDate, isEmpty, isObject } from './';
 
 describe('utils', () => {
 
@@ -70,27 +70,4 @@ describe('utils', () => {
       expect(isObject(value)).toBe(false);
     });
   });
-
-  describe('.properObject', () => {
-    it('returns given object when object has keys and hasOwnProperty function', () => {
-      const o = { a: 1 };
-      const a = [1];
-      expect(properObject(o)).toBe(o);
-      expect(properObject(a)).toBe(a);
-    });
-
-    it('returns given value when value is not an object', () => {
-      const o = 'hello';
-      expect(properObject(o)).toBe(o);
-    });
-
-    it('returns object that has given keys and hasOwnProperty function when given object is created from a null', () => {
-      const o = Object.create(null);
-      o.a = 1;
-      const actual = properObject(o);
-      expect(actual).toEqual({ a: 1 });
-      expect(typeof actual.hasOwnProperty === 'function').toBe(true);
-      expect(actual).not.toBe(o);
-    });
-  });
 });