Fix areEqual treating distinct Dates/RegExps as equal

areEqual fell through to its generic object branch for Date and RegExp
instances. There, Object.keys() returns an empty array for both values,
so the key-count and per-key checks pass vacuously and any two Dates
(or any two RegExps) were reported as equal regardless of their values.

This means change detection misses updates when an observable holds a
Date or RegExp: replacing new Date(0) with new Date(1000) would not be
seen as a change. Compare Dates by getTime() and RegExps by source+flags
before the object fallback, and add tests covering both.

Author: durvesh1992

src/utils/__tests__/areEqual.test.ts

@@ -171,12 +171,12 @@ describe('areEqual function', () => {
   describe('Type mismatch comparisons', () => {
     test('Map vs non-Map returns false', () => {
       const map = new Map([['key', 'value']]);
-      expect(areEqual(map, { key: 'value' }, ComparisonMethod.ShallowEqual)).toBe(
-        false
-      );
-      expect(areEqual({ key: 'value' }, map, ComparisonMethod.ShallowEqual)).toBe(
-        false
-      );
+      expect(
+        areEqual(map, { key: 'value' }, ComparisonMethod.ShallowEqual)
+      ).toBe(false);
+      expect(
+        areEqual({ key: 'value' }, map, ComparisonMethod.ShallowEqual)
+      ).toBe(false);
       expect(areEqual(map, { key: 'value' }, ComparisonMethod.DeepEquals)).toBe(
         false
       );
@@ -187,8 +187,12 @@ describe('areEqual function', () => {
 
     test('Set vs non-Set returns false', () => {
       const set = new Set([1, 2, 3]);
-      expect(areEqual(set, [1, 2, 3], ComparisonMethod.ShallowEqual)).toBe(false);
-      expect(areEqual([1, 2, 3], set, ComparisonMethod.ShallowEqual)).toBe(false);
+      expect(areEqual(set, [1, 2, 3], ComparisonMethod.ShallowEqual)).toBe(
+        false
+      );
+      expect(areEqual([1, 2, 3], set, ComparisonMethod.ShallowEqual)).toBe(
+        false
+      );
       expect(areEqual(set, [1, 2, 3], ComparisonMethod.DeepEquals)).toBe(false);
       expect(areEqual([1, 2, 3], set, ComparisonMethod.DeepEquals)).toBe(false);
     });
@@ -231,21 +235,27 @@ describe('areEqual function', () => {
 
     test('Map vs primitive returns false', () => {
       const map = new Map();
-      expect(areEqual(map, 'string', ComparisonMethod.ShallowEqual)).toBe(false);
+      expect(areEqual(map, 'string', ComparisonMethod.ShallowEqual)).toBe(
+        false
+      );
       expect(areEqual(map, 42, ComparisonMethod.ShallowEqual)).toBe(false);
       expect(areEqual(map, true, ComparisonMethod.DeepEquals)).toBe(false);
     });
 
     test('Set vs primitive returns false', () => {
       const set = new Set();
-      expect(areEqual(set, 'string', ComparisonMethod.ShallowEqual)).toBe(false);
+      expect(areEqual(set, 'string', ComparisonMethod.ShallowEqual)).toBe(
+        false
+      );
       expect(areEqual(set, 42, ComparisonMethod.ShallowEqual)).toBe(false);
       expect(areEqual(set, true, ComparisonMethod.DeepEquals)).toBe(false);
     });
 
     test('Array vs primitive returns false', () => {
       const arr: unknown[] = [];
-      expect(areEqual(arr, 'string', ComparisonMethod.ShallowEqual)).toBe(false);
+      expect(areEqual(arr, 'string', ComparisonMethod.ShallowEqual)).toBe(
+        false
+      );
       expect(areEqual(arr, 42, ComparisonMethod.ShallowEqual)).toBe(false);
       expect(areEqual(arr, true, ComparisonMethod.DeepEquals)).toBe(false);
     });
@@ -369,4 +379,41 @@ describe('areEqual function', () => {
       expect(areEqual(obj3, obj4, ComparisonMethod.ShallowEqual)).toBe(false);
     });
   });
+
+  describe('Date and RegExp comparison', () => {
+    test('equal Dates with different references are equal', () => {
+      expect(
+        areEqual(new Date(0), new Date(0), ComparisonMethod.ShallowEqual)
+      ).toBe(true);
+      expect(
+        areEqual(new Date(0), new Date(0), ComparisonMethod.DeepEquals)
+      ).toBe(true);
+    });
+
+    test('Dates with different times are not equal', () => {
+      expect(
+        areEqual(new Date(0), new Date(1000), ComparisonMethod.ShallowEqual)
+      ).toBe(false);
+      expect(
+        areEqual(new Date(0), new Date(1000), ComparisonMethod.DeepEquals)
+      ).toBe(false);
+    });
+
+    test('a Date is not equal to a plain object', () => {
+      expect(areEqual(new Date(0), {}, ComparisonMethod.DeepEquals)).toBe(
+        false
+      );
+    });
+
+    test('equal RegExps with different references are equal', () => {
+      expect(areEqual(/abc/gi, /abc/gi, ComparisonMethod.ShallowEqual)).toBe(
+        true
+      );
+    });
+
+    test('RegExps with different patterns or flags are not equal', () => {
+      expect(areEqual(/abc/g, /abd/g, ComparisonMethod.DeepEquals)).toBe(false);
+      expect(areEqual(/abc/g, /abc/i, ComparisonMethod.DeepEquals)).toBe(false);
+    });
+  });
 });

src/utils/areEqual.ts

@@ -56,6 +56,24 @@ export function areEqual(
     return false;
   }
 
+  // Compare Dates by their time value. Without this, two Date instances fall
+  // through to the object branch below, where Object.keys() is empty for both,
+  // so any two Dates would incorrectly be considered equal.
+  if (a instanceof Date !== b instanceof Date) {
+    return false;
+  }
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+
+  // Compare RegExps by their source and flags, for the same reason as Dates.
+  if (a instanceof RegExp !== b instanceof RegExp) {
+    return false;
+  }
+  if (a instanceof RegExp && b instanceof RegExp) {
+    return a.source === b.source && a.flags === b.flags;
+  }
+
   // Compare Maps
   if (a instanceof Map !== b instanceof Map) {
     return false;