devicer.js 1.0.12 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devicer.js",
-  "version": "1.0.12",
+  "version": "1.1.0",
   "description": "Open-Source Digital Fingerprinting Middleware",
   "main": "src/main.js",
   "scripts": {

package/src/libs/confidence.js

@@ -7,7 +7,8 @@ function compareArrays(arr1, arr2, max_depth = 5) {
     let matches = 0;
     // Ensure max_depth is not exceeded
     if (max_depth <= 0) {
-        throw new Error("Max depth exceeded");
+        console.warn("Max depth exceeded in compareArrays");
+        return [0, 0]; // Return 0 fields and matches if max depth is exceeded
     }
     // Sort arrays to ensure consistent comparison
     const sortedArr1 = arr1.map((item) => JSON.stringify(item)).sort().map((item) => {
@@ -40,7 +41,7 @@ function compareArrays(arr1, arr2, max_depth = 5) {
             fields += subData[0] - 1; // Subtract 1 for the index itself
             matches += subData[1];
         }
-        if (sortedArr1[i] === sortedArr2[i]) {
+        if (sortedArr2.includes(sortedArr1[i]) && sortedArr1[i]) {
             matches++;
         }
     }
@@ -52,19 +53,20 @@ function compareDatasets(data1, data2, max_depth = 5) {
     let matches = 0;
     // Ensure max_depth is not exceeded
     if (max_depth <= 0) {
-        throw new Error("Max depth exceeded");
+        console.warn("Max depth exceeded in compareDatasets");
+        return [0, 0]; // Return 0 fields and matches if max depth is exceeded
     }
     for (const key in data1) {
         if (data1[key] !== undefined && data2[key] !== undefined) {
             fields++;
-            if ((typeof data1[key] == "object" && data1[key]) &&
-                (typeof data2[key] == "object" && data2[key])) {
-                const subData = compareDatasets(data1[key], data2[key], max_depth - 1);
+            if (Array.isArray(data1[key]) && Array.isArray(data2[key])) {
+                const subData = compareArrays(data1[key], data2[key], max_depth - 1);
                 fields += subData[0] - 1; // Subtract 1 for the key itself
                 matches += subData[1];
             }
-            else if (Array.isArray(data1[key]) && Array.isArray(data2[key])) {
-                const subData = compareArrays(data1[key], data2[key], max_depth - 1);
+            else if ((typeof data1[key] == "object" && data1[key]) &&
+                (typeof data2[key] == "object" && data2[key])) {
+                const subData = compareDatasets(data1[key], data2[key], max_depth - 1);
                 fields += subData[0] - 1; // Subtract 1 for the key itself
                 matches += subData[1];
             }

package/src/libs/confidence.ts

@@ -11,7 +11,8 @@ export function compareArrays(
 
   // Ensure max_depth is not exceeded
   if (max_depth <= 0) {
-    throw new Error("Max depth exceeded");
+    console.warn("Max depth exceeded in compareArrays");
+    return [0, 0]; // Return 0 fields and matches if max depth is exceeded
   }
 
   // Sort arrays to ensure consistent comparison
@@ -45,9 +46,7 @@ export function compareArrays(
       );
       fields += subData[0] - 1; // Subtract 1 for the index itself
       matches += subData[1];
-    }
-    
-    else if (
+    } else if (
       (typeof sortedArr1[i] == "object" && sortedArr1[i]) &&
       (typeof sortedArr2[i] == "object" && sortedArr2[i])
     ) {
@@ -60,7 +59,7 @@ export function compareArrays(
       matches += subData[1];
     }
 
-    if (sortedArr1[i] === sortedArr2[i]) {
+    if (sortedArr2.includes(sortedArr1[i]) && sortedArr1[i]) {
       matches++;
     }
   }
@@ -77,13 +76,18 @@ export function compareDatasets(
 
   // Ensure max_depth is not exceeded
   if (max_depth <= 0) {
-    throw new Error("Max depth exceeded");
+    console.warn("Max depth exceeded in compareDatasets");
+    return [0, 0]; // Return 0 fields and matches if max depth is exceeded
   }
 
   for (const key in data1) {
     if (data1[key] !== undefined && data2[key] !== undefined) {
       fields++;
-      if (
+      if (Array.isArray(data1[key]) && Array.isArray(data2[key])) {
+        const subData = compareArrays(data1[key], data2[key], max_depth - 1);
+        fields += subData[0] - 1; // Subtract 1 for the key itself
+        matches += subData[1];
+      } else if (
         (typeof data1[key] == "object" && data1[key]) &&
         (typeof data2[key] == "object" && data2[key])
       ) {
@@ -94,15 +98,7 @@ export function compareDatasets(
         );
         fields += subData[0] - 1; // Subtract 1 for the key itself
         matches += subData[1];
-      }
-      
-      else if (Array.isArray(data1[key]) && Array.isArray(data2[key])) {
-        const subData = compareArrays(data1[key], data2[key], max_depth - 1);
-        fields += subData[0] - 1; // Subtract 1 for the key itself
-        matches += subData[1];
-      }
-
-      else if (data1[key] == data2[key]) {
+      } else if (data1[key] == data2[key]) {
         matches++;
       }
     }

package/tests/comparisons.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { compareArrays, compareDatasets } from "../src/libs/confidence";
+import { compareArrays } from "../src/libs/confidence";
 
 describe("Array Comparison", () => {
   it("should compare two identical arrays", () => {
@@ -75,8 +75,42 @@ describe("Array Comparison", () => {
   });
 
   it("should throw an error for max depth exceeded", () => {
-    const arr1 = [1, [2, [3, [4, [5, [6]]]]]];
-    const arr2 = [1, [2, [3, [4, [5, [6]]]]]];
-    expect(() => compareArrays(arr1, arr2, 0)).toThrow("Max depth exceeded");
+    const arr1 = [1, 2, 3, [4, 5, 6]];
+    const arr2 = [1, 2, 3, [4, 5, 6]];
+    const result = compareArrays(arr1, arr2, 1); // Set max depth to 1
+    console.log("Result:", result);
+    expect(result).toEqual([3, 3]); // 3 fields, 3 matches
+  });
+
+  it("should handle arrays with shuffled identical elements", () => {
+    const arr1 = [1, 2, 3];
+    const arr2 = [3, 1, 2];
+    const result = compareArrays(arr1, arr2);
+    console.log("Result:", result);
+    expect(result).toEqual([3, 3]); // 3 fields, 3 matches
+  });
+
+  it("should handle arrays with shuffled different elements", () => {
+    const arr1 = ["a", "b", "c"];
+    const arr2 = ["c", "d", "a"];
+    const result = compareArrays(arr1, arr2);
+    console.log("Result:", result);
+    expect(result).toEqual([3, 2]); // 3 fields, 2 matches
+  });
+
+  it("should handle arrays with mixed types", () => {
+    const arr1 = [1, "two", true];
+    const arr2 = [1, "two", false];
+    const result = compareArrays(arr1, arr2);
+    console.log("Result:", result);
+    expect(result).toEqual([3, 2]); // 3 fields, 2 matches
+  });
+
+  it("should not count undefined values as matches", () => {
+    const arr1 = [1, 2, undefined];
+    const arr2 = [1, 2, undefined];
+    const result = compareArrays(arr1, arr2);
+    console.log("Result:", result);
+    expect(result).toEqual([3, 2]); // 3 fields, 2 matches
   });
 });