frontend: change equal argument types to unknown for safer typing

Using `unknown` enforces type safety by requiring explicit type
checks or assertions before performing operations on the values.

Also updated `Object.keys` usage with a more precise type assertion
to satisfy TypeScript's stricter checks when working with `unknown`.

This version now also supports date and regexp.

Author: thisconnect

frontends/web/src/utils/equal.test.tsx

@@ -114,5 +114,33 @@ describe('equal', () => {
       expect(equal(a, null)).toBeFalsy();
       expect(equal(null, a)).toBeFalsy();
     });
+
+    it('deep compares nested structures', () => {
+      const a = { foo: [1, { bar: 'baz' }] };
+      const b = { foo: [1, { bar: 'baz' }] };
+      expect(equal(a, b)).toBeTruthy();
+    });
+
+  });
+
+  describe('RegExp, functions and dates are currently not supported', () => {
+
+    it('compares RegExp objects correctly', () => {
+      expect(equal(/foo/g, /foo/g)).toBeTruthy();
+      expect(equal(/foo/g, /bar/g)).toBeFalsy();
+    });
+
+    it('compares Date objects correctly', () => {
+      expect(equal(new Date('2020-01-01'), new Date('2020-01-01'))).toBeTruthy();
+      expect(equal(new Date('2020-01-01'), new Date('2021-01-01'))).toBeFalsy();
+    });
+
+    it('does not consider functions equal', () => {
+      const a = () => {};
+      const b = () => {};
+      expect(equal(a, b)).toBeFalsy();
+    });
+    
   });
+
 });

frontends/web/src/utils/equal.ts

@@ -15,14 +15,46 @@
  */
 
 const isArray = Array.isArray;
-const keyList = Object.keys;
 const hasProp = Object.prototype.hasOwnProperty;
+const typedKeys = <T extends object>(obj: Readonly<T>): readonly (keyof T)[] => {
+  return Object.keys(obj) as (keyof T)[];
+};
 
-export const equal = (a: any, b: any): boolean => {
+/**
+ * Performs a deep equality check between two values.
+ *
+ * This function compares primitive types, arrays, plain objects, Date instances,
+ * and RegExp objects. It returns true if the values are deeply equal, false otherwise.
+ *
+ * - Uses `Object.is` for primitive comparison (handles `NaN`, `-0`, etc.)
+ * - Recursively checks array contents and object properties
+ * - Properly compares Date and RegExp objects
+ * - Returns false for functions, symbols, maps, sets, or class instances (not handled)
+ *
+ * @param a - The first value to compare.
+ * @param b - The second value to compare.
+ * @returns `true` if values are deeply equal, `false` otherwise.
+ */
+export const equal = (a: unknown, b: unknown): boolean => {
   if (Object.is(a, b)) {
     return true;
   }
 
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+
+  if (a instanceof RegExp && b instanceof RegExp) {
+    return a.toString() === b.toString();
+  }
+
+  if (
+    (a instanceof Date) !== (b instanceof Date)
+    || (a instanceof RegExp) !== (b instanceof RegExp)
+  ) {
+    return false;
+  }
+
   if (a && b && typeof a === 'object' && typeof b === 'object') {
     if (isArray(a) && isArray(b)) {
       if (a.length !== b.length) {
@@ -40,19 +72,18 @@ export const equal = (a: any, b: any): boolean => {
       return false;
     }
 
-    const length = keyList(a).length;
-    if (length !== keyList(b).length) {
+    const aKeys = typedKeys(a);
+    const bKeys = typedKeys(b);
+
+    if (aKeys.length !== bKeys.length) {
       return false;
     }
 
-    for (let i = 0; i < length; i++) {
-      if (!hasProp.call(b, keyList(a)[i])) {
+    for (const key of aKeys) {
+      if (!hasProp.call(b, key)) {
         return false;
       }
-    }
-
-    for (let i = 0; i < length; i++) {
-      if (!equal(a[keyList(a)[i]], b[keyList(a)[i]])) {
+      if (!equal(a[key], b[key])) {
         return false;
       }
     }
@@ -61,4 +92,4 @@ export const equal = (a: any, b: any): boolean => {
   }
 
   return false;
-}
+};