@adventurelabs/scout-core 1.0.111 → 1.0.113

package/dist/hooks/useScoutRefresh.js

@@ -91,75 +91,58 @@ export function useScoutRefresh(options = {}) {
         }
         return true;
     }, []);
-    // Helper function to find differences between herd modules for debugging
-    const findHerdModulesDifferences = useCallback((newData, currentData) => {
-        if (!Array.isArray(newData) || !Array.isArray(currentData)) {
-            return `Array type mismatch: new=${Array.isArray(newData)}, current=${Array.isArray(currentData)}`;
-        }
-        if (newData.length !== currentData.length) {
-            return `Array length mismatch: new=${newData.length}, current=${currentData.length}`;
-        }
-        const differences = [];
-        for (let i = 0; i < newData.length; i++) {
-            const newHerd = newData[i];
-            const currentHerd = currentData[i];
-            if (!newHerd || !currentHerd) {
-                differences.push(`Herd ${i}: null/undefined mismatch`);
-                continue;
-            }
-            // Check top-level fields
-            const fieldsToCheck = [
-                "timestamp_last_refreshed",
-                "total_events",
-                "total_events_with_filters",
-                "events_page_index",
-            ];
-            fieldsToCheck.forEach((field) => {
-                if (newHerd[field] !== currentHerd[field]) {
-                    differences.push(`Herd ${i}.${field}: ${currentHerd[field]} → ${newHerd[field]}`);
-                }
-            });
-            // Check array lengths for nested data
-            const arrayFields = [
-                "devices",
-                "events",
-                "plans",
-                "zones",
-                "sessions",
-                "layers",
-                "providers",
-            ];
-            arrayFields.forEach((field) => {
-                const newArray = newHerd[field];
-                const currentArray = currentHerd[field];
-                if (Array.isArray(newArray) && Array.isArray(currentArray)) {
-                    if (newArray.length !== currentArray.length) {
-                        differences.push(`Herd ${i}.${field}[]: length ${currentArray.length} → ${newArray.length}`);
-                    }
-                }
-            });
-        }
-        return differences.length > 0
-            ? differences.join(", ")
-            : "No significant differences found";
+    // Helper function to sort herd modules consistently by ID
+    const sortHerdModulesById = useCallback((herdModules) => {
+        if (!Array.isArray(herdModules))
+            return herdModules;
+        return [...herdModules].sort((a, b) => {
+            const aId = a?.herd?.id || 0;
+            const bId = b?.herd?.id || 0;
+            return aId - bId;
+        });
+    }, []);
+    // Helper function to normalize herd modules for comparison (excludes timestamp metadata)
+    const normalizeHerdModulesForComparison = useCallback((herdModules) => {
+        if (!Array.isArray(herdModules))
+            return herdModules;
+        return herdModules.map((hm) => {
+            if (!hm || typeof hm !== "object")
+                return hm;
+            // Create a copy without timestamp metadata that doesn't represent business data changes
+            const { timestamp_last_refreshed, ...businessData } = hm;
+            return businessData;
+        });
     }, []);
-    // Helper function to conditionally dispatch only if data has changed
-    const conditionalDispatch = useCallback((newData, currentData, actionCreator, dataType, enableDebugging = false) => {
-        if (!deepEqual(newData, currentData)) {
-            console.log(`[useScoutRefresh] ${dataType} data changed, updating store`);
-            // Add debugging for herd modules to see what actually changed
-            if (enableDebugging && dataType.includes("Herd modules")) {
-                const differences = findHerdModulesDifferences(newData, currentData);
-                console.log(`[useScoutRefresh] ${dataType} differences: ${differences}`);
+    // Helper function to conditionally dispatch only if business data has changed
+    const conditionalDispatch = useCallback((newData, currentData, actionCreator, dataType, skipTimestampOnlyUpdates = false) => {
+        // For herd modules, sort both datasets by ID before comparison
+        let dataToCompare = newData;
+        let currentToCompare = currentData;
+        if (dataType.includes("Herd modules")) {
+            dataToCompare = sortHerdModulesById(newData);
+            currentToCompare = sortHerdModulesById(currentData);
+            // If we want to skip timestamp-only updates, normalize the data for comparison
+            if (skipTimestampOnlyUpdates) {
+                dataToCompare = normalizeHerdModulesForComparison(dataToCompare);
+                currentToCompare =
+                    normalizeHerdModulesForComparison(currentToCompare);
             }
-            dispatch(actionCreator(newData));
+        }
+        if (!deepEqual(dataToCompare, currentToCompare)) {
+            console.log(`[useScoutRefresh] ${dataType} business data changed, updating store`);
+            dispatch(actionCreator(newData)); // Always dispatch original unsorted data
             return true;
         }
         else {
-            console.log(`[useScoutRefresh] ${dataType} data unchanged, skipping store update`);
+            console.log(`[useScoutRefresh] ${dataType} business data unchanged, skipping store update`);
             return false;
         }
-    }, [dispatch, deepEqual, findHerdModulesDifferences]);
+    }, [
+        dispatch,
+        deepEqual,
+        sortHerdModulesById,
+        normalizeHerdModulesForComparison,
+    ]);
     // Helper function to handle IndexedDB errors - memoized for stability
     const handleIndexedDbError = useCallback(async (error, operation, retryFn) => {
         if (error instanceof Error &&
@@ -266,7 +249,7 @@ export function useScoutRefresh(options = {}) {
                                                 }
                                             });
                                         }
-                                        // Conditionally update store with fresh background data using normalized comparison
+                                        // Conditionally update store with fresh background data, skip timestamp-only changes
                                         const currentHerdModules = store.getState().scout.herd_modules;
                                         const currentUser = store.getState().scout.user;
                                         conditionalDispatch(backgroundHerdModulesResult.data, currentHerdModules, setHerdModules, "Herd modules (background)", true);
@@ -378,7 +361,7 @@ export function useScoutRefresh(options = {}) {
                     await scoutCache.setHerdModules(compatible_new_herd_modules, cacheTtlMs);
                 });
             }
-            // Step 4: Conditionally update store with fresh data using normalized comparison
+            // Step 4: Conditionally update store with fresh data, skip timestamp-only changes
             const dataProcessingStartTime = Date.now();
             const currentHerdModules = store.getState().scout.herd_modules;
             const currentUser = store.getState().scout.user;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adventurelabs/scout-core",
-  "version": "1.0.111",
+  "version": "1.0.113",
   "description": "Core utilities and helpers for Adventure Labs Scout applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",