Fixed bugs

Author: stefanrammo

README.md

@@ -24,7 +24,7 @@ npm test
 To test the time sync functionality using simulated response:
 
 ```bash
-node test/timeSync.test.js
+node test/testTimeSync.js
 ```
 
 

event.js

@@ -5,7 +5,7 @@ const Client = require('./client');
 
 /**
  * Recursively normalizes an object/value.
- * If the value is a string, it trims whitespace.
+ * If the value is a string, it trims whitespace and compresses internal whitespace.
  * If it's an object (or array), it normalizes each property.
  * This helps ensure that logically identical values produce the same string.
  *
@@ -14,7 +14,7 @@ const Client = require('./client');
  */
 function normalizeValue(val) {
   if (typeof val === 'string') {
-    return val.trim();
+    return val.trim().replace(/\s+/g, ' ');
   } else if (typeof val === 'object' && val !== null) {
     if (Array.isArray(val)) {
       return val.map(normalizeValue);
@@ -51,61 +51,98 @@ function canonicalize(obj) {
   return '{' + result + '}';
 }
 
+/**
+ * Orders the keys of an object based on a desired order.
+ * Keys in the desiredOrder array appear first (in that order) and any remaining keys
+ * are appended in alphabetical order.
+ *
+ * @param {Object} obj - The object whose keys are to be ordered.
+ * @returns {Object} - A new object with keys in the desired order.
+ */
+function orderObjectKeys(obj) {
+  if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) {
+    return obj;
+  }
+  // Define your desired key order
+  const desiredOrder = ["Level", "Group", "Description", "Text"];
+  const ordered = {};
+
+  // Add keys in the desired order if they exist in the object
+  for (const key of desiredOrder) {
+    if (key in obj) {
+      ordered[key] = obj[key];
+    }
+  }
+
+  // Get any keys not in the desired order and sort them alphabetically
+  const remainingKeys = Object.keys(obj)
+    .filter(key => !desiredOrder.includes(key))
+    .sort();
+
+  for (const key of remainingKeys) {
+    ordered[key] = obj[key];
+  }
+  return ordered;
+}
+
 (async function main() {
   const client = new Client('ws://127.0.0.1:17000', false);
   try {
-    // Example query: adjust the time range, etc., as needed:
+    // Wide time range and large limit
     const query = {
-      timeRangeBegin: 1742540000,
-      timeRangeEnd:   1742550000,
-      codeMask:       0xFFFFFFFF,
-      limit:          100,
+      timeRangeBegin: 0,            // start from the epoch
+      timeRangeEnd:   2147483647,     // far in the future
+      codeMask:       0xFFFFFFFF,     // all codes
+      limit:          1000,           // max number of events to retrieve
       offset:         0,
-      flags:          1  // 'NewestFirst' from your enum
+      flags:          1               // e.g. 'NewestFirst'
     };
 
     const events = await client.requestEvents(query);
 
-    // De-duplicate events using a composite key built from normalized fields.
-    // We'll canonicalize e.data to handle reordered JSON keys.
+    // -----------------------------------------------------------------------
+    // Deduplicate events:
+    // Use only the sender and the event's data (after normalizing and ordering)
+    // to build a composite key. This ignores differences in timestamp, code,
+    // or JSON key order.
+    // -----------------------------------------------------------------------
     const seen = new Set();
     const uniqueEvents = [];
 
     for (const e of events) {
-      const tsPart = (typeof e.timestampSec !== 'undefined' && e.timestampSec !== null)
-        ? String(e.timestampSec)
-        : '';
+      const senderPart = (typeof e.sender === 'string') ? e.sender : '';
 
-      const codePart = (typeof e.code !== 'undefined' && e.code !== null)
-        ? String(e.code)
-        : '';
-
-      const senderPart = (typeof e.sender !== 'undefined' && e.sender !== null)
-        ? String(e.sender)
-        : '';
-
-      // Canonicalize the data so that JSON field order does not matter
-      const dataPart = e.data
-        ? canonicalize(normalizeValue(e.data))
-        : '';
+      // Process the data: normalize, then order the keys
+      let dataPart = '';
+      if (e.data) {
+        const normalizedData = normalizeValue(e.data);
+        const orderedData = orderObjectKeys(normalizedData);
+        dataPart = canonicalize(orderedData);
+      }
 
-      const compositeKey = `${tsPart}-${codePart}-${senderPart}-${dataPart}`;
+      // Build composite key from sender and data only
+      const compositeKey = `${senderPart}-${dataPart}`;
 
       if (!seen.has(compositeKey)) {
         seen.add(compositeKey);
         uniqueEvents.push(e);
       }
     }
 
-    // Print the unique events
+    // Print the final unique events, with data keys ordered for display
     if (uniqueEvents.length === 0) {
-      console.log("No events found.");
+      console.log("No events found (after dedup).");
     } else {
+      console.log(`Showing ${uniqueEvents.length} unique events:\n`);
       for (const evt of uniqueEvents) {
         console.log(`Timestamp: ${evt.timestampSec}`);
         console.log(`Code:      ${evt.code}`);
         console.log(`Sender:    ${evt.sender}`);
-        console.log(`Data:      ${JSON.stringify(evt.data)}`);
+        let orderedData = evt.data;
+        if (typeof evt.data === 'object' && evt.data !== null && !Array.isArray(evt.data)) {
+          orderedData = orderObjectKeys(evt.data);
+        }
+        console.log(`Data:      ${JSON.stringify(orderedData)}`);
         console.log('--------------------');
       }
     }