@adventurelabs/scout-core 1.0.112 → 1.0.113

package/dist/hooks/useScoutRefresh.js

@@ -101,94 +101,48 @@ export function useScoutRefresh(options = {}) {
             return aId - bId;
         });
     }, []);
-    // 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}`;
-        }
-        // Sort both arrays by herd ID for consistent comparison
-        const sortedNew = sortHerdModulesById(newData);
-        const sortedCurrent = sortHerdModulesById(currentData);
-        const differences = [];
-        for (let i = 0; i < sortedNew.length; i++) {
-            const newHerd = sortedNew[i];
-            const currentHerd = sortedCurrent[i];
-            if (!newHerd || !currentHerd) {
-                differences.push(`Herd ${i}: null/undefined mismatch`);
-                continue;
-            }
-            // Get herd identifiers for better debugging
-            const newHerdId = newHerd.herd?.id || "unknown";
-            const currentHerdId = currentHerd.herd?.id || "unknown";
-            const newHerdName = newHerd.herd?.name || "unknown";
-            const currentHerdName = currentHerd.herd?.name || "unknown";
-            // Check if herd IDs match (data shuffling detection)
-            if (newHerdId !== currentHerdId) {
-                differences.push(`Herd ${i}: ID mismatch - expected ${currentHerdId}(${currentHerdName}) got ${newHerdId}(${newHerdName})`);
-            }
-            // 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}(${newHerdName}).${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}(${newHerdName}).${field}[]: length ${currentArray.length} → ${newArray.length}`);
-                    }
-                }
-            });
-        }
-        return differences.length > 0
-            ? differences.join(", ")
-            : "No significant differences found";
+    // 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) => {
+    // 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);
+            }
         }
         if (!deepEqual(dataToCompare, currentToCompare)) {
-            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}`);
-            }
+            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, sortHerdModulesById]);
+    }, [
+        dispatch,
+        deepEqual,
+        sortHerdModulesById,
+        normalizeHerdModulesForComparison,
+    ]);
     // Helper function to handle IndexedDB errors - memoized for stability
     const handleIndexedDbError = useCallback(async (error, operation, retryFn) => {
         if (error instanceof Error &&
@@ -295,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);
@@ -407,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.112",
+  "version": "1.0.113",
   "description": "Core utilities and helpers for Adventure Labs Scout applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",