@adventurelabs/scout-core 1.0.58 → 1.0.60

package/README.md

@@ -1,7 +1,108 @@
-# @adventurelabs/scout-core
+# Scout Core
 
 Core utilities and helpers for Adventure Labs Scout applications.
 
+## Features
+
+- **Herd Management**: Comprehensive herd and device management
+- **Event Tracking**: Wildlife event monitoring and tagging
+- **Real-time Updates**: Supabase-powered real-time data synchronization
+- **State Management**: Redux-based state management with loading states
+
+## Herd Modules Loading State
+
+The core provides a global loading state for herd modules, which are essential for many consuming applications. This state tracks whether herd modules are currently loading, have loaded successfully, or failed to load.
+
+### Loading State Enum
+
+```typescript
+import { EnumHerdModulesLoadingState } from "@adventurelabs/scout-core";
+
+enum EnumHerdModulesLoadingState {
+  NOT_LOADING = "NOT_LOADING",
+  LOADING = "LOADING",
+  SUCCESSFULLY_LOADED = "SUCCESSFULLY_LOADED",
+  UNSUCCESSFULLY_LOADED = "UNSUCCESSFULLY_LOADED",
+}
+
+**Available Hooks:**
+- `useHerdModulesLoadingState()` - Get current loading state
+- `useIsHerdModulesLoading()` - Check if currently loading
+- `useIsHerdModulesLoaded()` - Check if successfully loaded
+- `useIsHerdModulesFailed()` - Check if loading failed
+- `useHerdModulesLoadedAt()` - Get how long the last loading took (in milliseconds)
+- `useHerdModulesLoadingDuration()` - Get loading duration in milliseconds
+- `useHerdModulesLoadingTimeAgo()` - Get formatted time ago since last loaded (e.g., "2.5s ago")
+```
+
+### Usage in Components
+
+```typescript
+import {
+  useHerdModulesLoadingState,
+  useIsHerdModulesLoading,
+  useIsHerdModulesLoaded,
+  useIsHerdModulesFailed,
+  useHerdModulesLoadedAt,
+  useHerdModulesLoadingTimeAgo,
+  useHerdModulesLoadingDuration,
+} from "@adventurelabs/scout-core";
+
+function MyComponent() {
+  const loadingState = useHerdModulesLoadingState();
+  const isLoading = useIsHerdModulesLoading();
+  const isLoaded = useIsHerdModulesLoaded();
+  const isFailed = useIsHerdModulesFailed();
+
+  if (isLoading) {
+    return <div>Loading herd modules...</div>;
+  }
+
+  if (isFailed) {
+    return <div>Failed to load herd modules</div>;
+  }
+
+  if (isLoaded) {
+    return <div>Herd modules loaded successfully!</div>;
+  }
+
+  return <div>Not loading</div>;
+}
+
+// Example with loading duration information
+function HerdModulesStatus() {
+  const loadingState = useHerdModulesLoadingState();
+  const loadingTimeMs = useHerdModulesLoadedAt();
+  const timeAgo = useHerdModulesLoadingTimeAgo();
+  const loadingDuration = useHerdModulesLoadingDuration();
+
+  return (
+    <div>
+      <div>Status: {loadingState}</div>
+      {loadingTimeMs && (
+        <>
+          <div>Last loading took: {loadingTimeMs}ms</div>
+          <div>Loaded: {timeAgo}</div>
+          <div>Loading duration: {loadingDuration}ms</div>
+        </>
+      )}
+    </div>
+  );
+}
+```
+
+### Manual Refresh
+
+```typescript
+import { useScoutRefresh } from "@adventurelabs/scout-core";
+
+function RefreshButton() {
+  const { handleRefresh } = useScoutRefresh({ autoRefresh: false });
+
+  return <button onClick={handleRefresh}>Refresh Data</button>;
+}
+```
+
 ## Installation
 
 ```bash
@@ -10,9 +111,31 @@ npm install @adventurelabs/scout-core
 yarn add @adventurelabs/scout-core
 ```
 
-## Usage
+## Setup
+
+Wrap your app with the ScoutRefreshProvider:
 
 ```typescript
+import { ScoutRefreshProvider } from "@adventurelabs/scout-core";
+
+function App() {
+  return (
+    <ScoutRefreshProvider>{/* Your app components */}</ScoutRefreshProvider>
+  );
+}
+```
+
+## Recent Updates
+
+- **v1.0.58**: Added global herd modules loading state tracking with timestamps
+- Fixed repeat Supabase client creation logs
+- Enhanced loading state management for better UX
+- Added loading duration and time-ago tracking
+- Added comprehensive edge case handling and race condition prevention
+
+## Usage
+
+````typescript
 import "../../app/globals.css";
 import StoreProvider from "../../components/Store/StoreProvider";
 import { ScoutRefreshProvider } from "@adventurelabs/scout-core";
@@ -33,7 +156,6 @@ export default function ScoutLayout({
     </StoreProvider>
   );
 }
-```
 
 ## Available Modules
 
@@ -42,6 +164,7 @@ export default function ScoutLayout({
 - Database types from Supabase
 - Herd, Device, Event, User interfaces
 - Request/Response types
+- Herd module loading state enums (`EnumHerdModulesLoadingState`)
 
 ### Helpers
 
@@ -95,7 +218,7 @@ function ConnectionStatus() {
 
   return <div>Status: {isConnected ? "Connected" : "Disconnected"}</div>;
 }
-```
+````
 
 ### Store
 
@@ -128,3 +251,10 @@ yarn clean
 ## License
 
 GPL-3.0
+
+**New Hooks** (in `core/store/hooks.ts`):
+
+- `useHerdModulesLoadingState()` - Get current loading state
+- `useIsHerdModulesLoading()` - Check if currently loading
+- `useIsHerdModulesLoaded()` - Check if successfully loaded
+- `

package/dist/hooks/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./useScoutDbListener";
-export * from "./useScoutRefresh";
+export { useScoutDbListener } from "./useScoutDbListener";
+export { useScoutRefresh, type UseScoutRefreshOptions, } from "./useScoutRefresh";

package/dist/hooks/index.js

@@ -1,2 +1,2 @@
-export * from "./useScoutDbListener";
-export * from "./useScoutRefresh";
+export { useScoutDbListener } from "./useScoutDbListener";
+export { useScoutRefresh, } from "./useScoutRefresh";

package/dist/hooks/useScoutRefresh.d.ts

@@ -2,6 +2,37 @@ export interface UseScoutRefreshOptions {
     autoRefresh?: boolean;
     onRefreshComplete?: () => void;
 }
+/**
+ * Hook for refreshing scout data with detailed timing measurements
+ *
+ * @param options - Configuration options for the refresh behavior
+ * @param options.autoRefresh - Whether to automatically refresh on mount (default: true)
+ * @param options.onRefreshComplete - Callback function called when refresh completes
+ *
+ * @returns Object containing:
+ * - handleRefresh: Function to manually trigger a refresh
+ * - getTimingStats: Function to get detailed timing statistics for the last refresh
+ *
+ * @example
+ * ```tsx
+ * const { handleRefresh, getTimingStats } = useScoutRefresh();
+ *
+ * // Get timing stats after a refresh
+ * const stats = getTimingStats();
+ * console.log('Herd modules API took:', stats.herdModulesApi, 'ms');
+ * console.log('User API took:', stats.userApi, 'ms');
+ * console.log('Data processing took:', stats.dataProcessing, 'ms');
+ * console.log('LocalStorage operations took:', stats.localStorage, 'ms');
+ * console.log('Total duration:', stats.totalDuration, 'ms');
+ * ```
+ */
 export declare function useScoutRefresh(options?: UseScoutRefreshOptions): {
     handleRefresh: () => Promise<void>;
+    getTimingStats: () => {
+        totalDuration: number;
+        herdModulesApi: number;
+        userApi: number;
+        dataProcessing: number;
+        localStorage: number;
+    };
 };

package/dist/hooks/useScoutRefresh.js

@@ -1,45 +1,165 @@
-import { useEffect } from "react";
+import { useEffect, useCallback, useRef } from "react";
 import { useAppDispatch } from "../store/hooks";
-import { EnumScoutStateStatus, setActiveHerdId, setHerdModules, setStatus, setUser, } from "../store/scout";
+import { EnumScoutStateStatus, setActiveHerdId, setHerdModules, setStatus, setHerdModulesLoadingState, setHerdModulesLoadedInMs, setHerdModulesApiDuration, setUserApiDuration, setDataProcessingDuration, setLocalStorageDuration, setUser, } from "../store/scout";
+import { EnumHerdModulesLoadingState } from "../types/herd_module";
 import { server_load_herd_modules } from "../helpers/herds";
 import { server_get_user } from "../helpers/users";
+/**
+ * Hook for refreshing scout data with detailed timing measurements
+ *
+ * @param options - Configuration options for the refresh behavior
+ * @param options.autoRefresh - Whether to automatically refresh on mount (default: true)
+ * @param options.onRefreshComplete - Callback function called when refresh completes
+ *
+ * @returns Object containing:
+ * - handleRefresh: Function to manually trigger a refresh
+ * - getTimingStats: Function to get detailed timing statistics for the last refresh
+ *
+ * @example
+ * ```tsx
+ * const { handleRefresh, getTimingStats } = useScoutRefresh();
+ *
+ * // Get timing stats after a refresh
+ * const stats = getTimingStats();
+ * console.log('Herd modules API took:', stats.herdModulesApi, 'ms');
+ * console.log('User API took:', stats.userApi, 'ms');
+ * console.log('Data processing took:', stats.dataProcessing, 'ms');
+ * console.log('LocalStorage operations took:', stats.localStorage, 'ms');
+ * console.log('Total duration:', stats.totalDuration, 'ms');
+ * ```
+ */
 export function useScoutRefresh(options = {}) {
     const { autoRefresh = true, onRefreshComplete } = options;
     const dispatch = useAppDispatch();
-    const handleRefresh = async () => {
-        dispatch(setStatus(EnumScoutStateStatus.LOADING));
+    const refreshInProgressRef = useRef(false);
+    // Refs to store timing measurements
+    const timingRefs = useRef({
+        startTime: 0,
+        herdModulesDuration: 0,
+        userApiDuration: 0,
+        dataProcessingDuration: 0,
+        localStorageDuration: 0,
+    });
+    const handleRefresh = useCallback(async () => {
+        // Prevent concurrent refresh calls
+        if (refreshInProgressRef.current) {
+            console.warn("[useScoutRefresh] Refresh already in progress, skipping");
+            return;
+        }
+        refreshInProgressRef.current = true;
+        const startTime = Date.now();
+        timingRefs.current.startTime = startTime;
         try {
+            dispatch(setStatus(EnumScoutStateStatus.LOADING));
+            dispatch(setHerdModulesLoadingState(EnumHerdModulesLoadingState.LOADING));
+            // Measure herd modules API call duration
+            const herdModulesStartTime = Date.now();
             const compatible_new_herd_modules = await server_load_herd_modules();
+            const herdModulesDuration = Date.now() - herdModulesStartTime;
+            timingRefs.current.herdModulesDuration = herdModulesDuration;
+            dispatch(setHerdModulesApiDuration(herdModulesDuration));
+            // Measure user API call duration
+            const userApiStartTime = Date.now();
             const res_new_user = await server_get_user();
+            const userApiDuration = Date.now() - userApiStartTime;
+            timingRefs.current.userApiDuration = userApiDuration;
+            dispatch(setUserApiDuration(userApiDuration));
+            // Validate API responses
+            if (!compatible_new_herd_modules ||
+                !Array.isArray(compatible_new_herd_modules)) {
+                throw new Error("Invalid herd modules response");
+            }
+            if (!res_new_user || !res_new_user.data) {
+                throw new Error("Invalid user response");
+            }
+            // Measure data processing duration
+            const dataProcessingStartTime = Date.now();
             dispatch(setHerdModules(compatible_new_herd_modules));
             dispatch(setUser(res_new_user.data));
-            // Check local storage for a last selected herd
-            if (localStorage.getItem("last_selected_herd")) {
-                const found_herd = compatible_new_herd_modules.find((hm) => hm.herd.id.toString() === localStorage.getItem("last_selected_herd"))?.herd;
-                // If herd is found then set it
-                if (found_herd) {
-                    dispatch(setActiveHerdId(found_herd.id.toString()));
+            dispatch(setHerdModulesLoadingState(EnumHerdModulesLoadingState.SUCCESSFULLY_LOADED));
+            const dataProcessingDuration = Date.now() - dataProcessingStartTime;
+            timingRefs.current.dataProcessingDuration = dataProcessingDuration;
+            dispatch(setDataProcessingDuration(dataProcessingDuration));
+            // Measure localStorage operations duration
+            const localStorageStartTime = Date.now();
+            // Safely handle localStorage operations
+            try {
+                // Check local storage for a last selected herd
+                const lastSelectedHerd = localStorage.getItem("last_selected_herd");
+                if (lastSelectedHerd) {
+                    const found_herd = compatible_new_herd_modules.find((hm) => hm.herd.id.toString() === lastSelectedHerd)?.herd;
+                    // If herd is found then set it
+                    if (found_herd) {
+                        dispatch(setActiveHerdId(found_herd.id.toString()));
+                    }
+                }
+                // If there is no last selected herd then select the first one
+                else if (compatible_new_herd_modules.length > 0) {
+                    const firstHerdId = compatible_new_herd_modules[0].herd.id.toString();
+                    localStorage.setItem("last_selected_herd", firstHerdId);
+                    dispatch(setActiveHerdId(firstHerdId));
                 }
             }
-            // If there is no last selected herd then select the first one
-            else if (compatible_new_herd_modules.length > 0) {
-                localStorage.setItem("last_selected_herd", compatible_new_herd_modules[0].herd.id.toString());
-                dispatch(setActiveHerdId(compatible_new_herd_modules[0].herd.id.toString()));
+            catch (localStorageError) {
+                console.warn("[useScoutRefresh] localStorage not available:", localStorageError);
+                // Fallback: select first herd without localStorage
+                if (compatible_new_herd_modules.length > 0) {
+                    dispatch(setActiveHerdId(compatible_new_herd_modules[0].herd.id.toString()));
+                }
             }
+            const localStorageDuration = Date.now() - localStorageStartTime;
+            timingRefs.current.localStorageDuration = localStorageDuration;
+            dispatch(setLocalStorageDuration(localStorageDuration));
+            const loadingDuration = Date.now() - startTime;
+            dispatch(setHerdModulesLoadedInMs(loadingDuration));
             dispatch(setStatus(EnumScoutStateStatus.DONE_LOADING));
+            // Log timing statistics
+            console.log("[useScoutRefresh] Refresh completed successfully. Timing breakdown:");
+            console.log(`  - Herd modules API: ${herdModulesDuration}ms`);
+            console.log(`  - User API: ${userApiDuration}ms`);
+            console.log(`  - Data processing: ${dataProcessingDuration}ms`);
+            console.log(`  - LocalStorage operations: ${localStorageDuration}ms`);
+            console.log(`  - Total duration: ${loadingDuration}ms`);
             onRefreshComplete?.();
         }
         catch (error) {
+            const loadingDuration = Date.now() - startTime;
             console.error("Error refreshing scout data:", error);
+            // Ensure consistent state updates on error
+            dispatch(setHerdModulesLoadingState(EnumHerdModulesLoadingState.UNSUCCESSFULLY_LOADED));
+            dispatch(setHerdModulesLoadedInMs(loadingDuration));
             dispatch(setStatus(EnumScoutStateStatus.DONE_LOADING));
+            // Log timing statistics even on error
+            console.log("[useScoutRefresh] Refresh failed. Partial timing breakdown:");
+            console.log(`  - Herd modules API: ${timingRefs.current.herdModulesDuration}ms`);
+            console.log(`  - User API: ${timingRefs.current.userApiDuration}ms`);
+            console.log(`  - Data processing: ${timingRefs.current.dataProcessingDuration}ms`);
+            console.log(`  - LocalStorage operations: ${timingRefs.current.localStorageDuration}ms`);
+            console.log(`  - Total duration: ${loadingDuration}ms`);
         }
-    };
+        finally {
+            refreshInProgressRef.current = false;
+        }
+    }, [dispatch, onRefreshComplete]);
     useEffect(() => {
         if (autoRefresh) {
             handleRefresh();
         }
-    }, [autoRefresh]);
+    }, [autoRefresh, handleRefresh]);
+    // Utility function to get timing statistics
+    const getTimingStats = useCallback(() => {
+        const now = Date.now();
+        const startTime = timingRefs.current.startTime;
+        return {
+            totalDuration: startTime > 0 ? now - startTime : 0,
+            herdModulesApi: timingRefs.current.herdModulesDuration,
+            userApi: timingRefs.current.userApiDuration,
+            dataProcessing: timingRefs.current.dataProcessingDuration,
+            localStorage: timingRefs.current.localStorageDuration,
+        };
+    }, []);
     return {
         handleRefresh,
+        getTimingStats,
     };
 }

package/dist/providers/ScoutRefreshProvider.js

@@ -2,7 +2,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useScoutRefresh } from "../hooks/useScoutRefresh";
 import { useScoutDbListener } from "../hooks/useScoutDbListener";
-import { createContext, useContext, useRef } from "react";
+import { createContext, useContext, useMemo } from "react";
 import { createBrowserClient } from "@supabase/ssr";
 // Create context for the Supabase client
 const SupabaseContext = createContext(null);
@@ -26,14 +26,13 @@ export function useConnectionStatus() {
 export function ScoutRefreshProvider({ children }) {
     const url = process.env.NEXT_PUBLIC_SUPABASE_URL || "";
     const anon_key = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY || "";
-    // Create a single Supabase client instance
-    const supabaseRef = useRef(null);
-    if (!supabaseRef.current) {
-        supabaseRef.current = createBrowserClient(url, anon_key);
-        console.log("[ScoutRefreshProvider] Created Supabase client");
-    }
+    // Create a single Supabase client instance using useMemo to prevent recreation
+    const supabaseClient = useMemo(() => {
+        console.log("[ScoutRefreshProvider] Creating Supabase client");
+        return createBrowserClient(url, anon_key);
+    }, [url, anon_key]);
     // Use the enhanced DB listener with connection status
-    useScoutDbListener(supabaseRef.current);
+    useScoutDbListener(supabaseClient);
     useScoutRefresh();
     // // Log connection status changes for debugging
     // if (connectionStatus.lastError) {
@@ -45,5 +44,5 @@ export function ScoutRefreshProvider({ children }) {
     // if (connectionStatus.isConnected) {
     //   console.log("[ScoutRefreshProvider] ✅ DB Listener connected");
     // }
-    return (_jsx(SupabaseContext.Provider, { value: supabaseRef.current, children: children }));
+    return (_jsx(SupabaseContext.Provider, { value: supabaseClient, children: children }));
 }

package/dist/store/hooks.d.ts

@@ -1 +1,8 @@
 export declare const useAppDispatch: <AppDispatch extends import("redux").Dispatch<import("redux").AnyAction> = import("redux").Dispatch<import("redux").AnyAction>>() => AppDispatch;
+export declare const useHerdModulesLoadingState: () => any;
+export declare const useIsHerdModulesLoading: () => boolean;
+export declare const useIsHerdModulesLoaded: () => boolean;
+export declare const useIsHerdModulesFailed: () => boolean;
+export declare const useHerdModulesLoadedAt: () => any;
+export declare const useHerdModulesLoadingDuration: () => any;
+export declare const useHerdModulesLoadingTimeAgo: () => string | null;

package/dist/store/hooks.js

@@ -1,3 +1,67 @@
-import { useDispatch } from "react-redux";
+import { useDispatch, useSelector } from "react-redux";
+import { EnumHerdModulesLoadingState } from "../types/herd_module";
 // Simple wrapper for useDispatch to maintain compatibility
 export const useAppDispatch = useDispatch;
+// Selector hook for herd modules loading state
+export const useHerdModulesLoadingState = () => {
+    return useSelector((state) => state.scout.herd_modules_loading_state);
+};
+// Selector hook for checking if herd modules are currently loading
+export const useIsHerdModulesLoading = () => {
+    return useSelector((state) => state.scout.herd_modules_loading_state ===
+        EnumHerdModulesLoadingState.LOADING);
+};
+// Selector hook for checking if herd modules loaded successfully
+export const useIsHerdModulesLoaded = () => {
+    return useSelector((state) => state.scout.herd_modules_loading_state ===
+        EnumHerdModulesLoadingState.SUCCESSFULLY_LOADED);
+};
+// Selector hook for checking if herd modules failed to load
+export const useIsHerdModulesFailed = () => {
+    return useSelector((state) => state.scout.herd_modules_loading_state ===
+        EnumHerdModulesLoadingState.UNSUCCESSFULLY_LOADED);
+};
+// Selector hook for getting when herd modules were last loaded
+export const useHerdModulesLoadedAt = () => {
+    return useSelector((state) => state.scout.herd_modules_loaded_in_ms);
+};
+// Selector hook for getting the loading duration in milliseconds
+export const useHerdModulesLoadingDuration = () => {
+    return useSelector((state) => {
+        return state.scout.herd_modules_loaded_in_ms;
+    });
+};
+// Selector hook for getting formatted loading time (e.g., "2.5s ago")
+export const useHerdModulesLoadingTimeAgo = () => {
+    return useSelector((state) => {
+        const loadingDuration = state.scout.herd_modules_loaded_in_ms;
+        if (!loadingDuration)
+            return null;
+        // Since we store the duration, we need to calculate when it was loaded
+        // We'll use the lastRefreshed timestamp from the store
+        const lastRefreshed = state.scout.lastRefreshed;
+        if (!lastRefreshed)
+            return null;
+        const now = Date.now();
+        const timeSinceLoaded = now - lastRefreshed;
+        // Handle edge case where timeSinceLoaded might be negative
+        if (timeSinceLoaded < 0) {
+            return "just now";
+        }
+        const diffSeconds = Math.floor(timeSinceLoaded / 1000);
+        const diffMinutes = Math.floor(diffSeconds / 60);
+        const diffHours = Math.floor(diffMinutes / 60);
+        if (diffHours > 0) {
+            return `${diffHours}h ago`;
+        }
+        else if (diffMinutes > 0) {
+            return `${diffMinutes}m ago`;
+        }
+        else if (diffSeconds > 0) {
+            return `${diffSeconds}s ago`;
+        }
+        else {
+            return "just now";
+        }
+    });
+};

package/dist/store/scout.d.ts

@@ -1,5 +1,5 @@
 import { IUser } from "../types/db";
-import { IHerdModule } from "../types/herd_module";
+import { IHerdModule, EnumHerdModulesLoadingState } from "../types/herd_module";
 export declare enum EnumScoutStateStatus {
     LOADING = "LOADING",
     DONE_LOADING = "DONE_LOADING"
@@ -7,6 +7,12 @@ export declare enum EnumScoutStateStatus {
 export interface ScoutState {
     herd_modules: IHerdModule[];
     status: EnumScoutStateStatus;
+    herd_modules_loading_state: EnumHerdModulesLoadingState;
+    herd_modules_loaded_in_ms: number | null;
+    herd_modules_api_duration_ms: number | null;
+    user_api_duration_ms: number | null;
+    data_processing_duration_ms: number | null;
+    localStorage_duration_ms: number | null;
     active_herd_id: string | null;
     active_device_id: string | null;
     lastRefreshed: number;
@@ -21,6 +27,30 @@ export declare const scoutSlice: import("@reduxjs/toolkit").Slice<ScoutState, {
         payload: any;
         type: string;
     }) => void;
+    setHerdModulesLoadingState: (state: import("immer").WritableDraft<ScoutState>, action: {
+        payload: any;
+        type: string;
+    }) => void;
+    setHerdModulesLoadedInMs: (state: import("immer").WritableDraft<ScoutState>, action: {
+        payload: any;
+        type: string;
+    }) => void;
+    setHerdModulesApiDuration: (state: import("immer").WritableDraft<ScoutState>, action: {
+        payload: any;
+        type: string;
+    }) => void;
+    setUserApiDuration: (state: import("immer").WritableDraft<ScoutState>, action: {
+        payload: any;
+        type: string;
+    }) => void;
+    setDataProcessingDuration: (state: import("immer").WritableDraft<ScoutState>, action: {
+        payload: any;
+        type: string;
+    }) => void;
+    setLocalStorageDuration: (state: import("immer").WritableDraft<ScoutState>, action: {
+        payload: any;
+        type: string;
+    }) => void;
     setActiveHerdId: (state: import("immer").WritableDraft<ScoutState>, action: {
         payload: any;
         type: string;
@@ -110,6 +140,6 @@ export declare const scoutSlice: import("@reduxjs/toolkit").Slice<ScoutState, {
         type: string;
     }) => void;
 }, "scout", "scout", import("@reduxjs/toolkit").SliceSelectors<ScoutState>>;
-export declare const setHerdModules: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setHerdModules">, setStatus: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setStatus">, setActiveHerdId: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setActiveHerdId">, setActiveDeviceId: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setActiveDeviceId">, appendEventsToHerdModule: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/appendEventsToHerdModule">, replaceEventsForHerdModule: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/replaceEventsForHerdModule">, updateEventValuesForHerdModule: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/updateEventValuesForHerdModule">, updatePageIndexForHerdModule: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/updatePageIndexForHerdModule">, appendPlansToHerdModule: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/appendPlansToHerdModule">, setUser: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setUser">, addTag: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/addTag">, deleteTag: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/deleteTag">, updateTag: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/updateTag">, addNewDeviceToHerdModule: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/addNewDeviceToHerdModule">, updateDeviceForHerdModule: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/updateDeviceForHerdModule">, addDevice: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/addDevice">, deleteDevice: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/deleteDevice">, updateDevice: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/updateDevice">, addPlan: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/addPlan">, deletePlan: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/deletePlan">, updatePlan: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/updatePlan">, addSessionToStore: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/addSessionToStore">, deleteSessionFromStore: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/deleteSessionFromStore">, updateSessionInStore: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/updateSessionInStore">;
+export declare const setHerdModules: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setHerdModules">, setStatus: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setStatus">, setHerdModulesLoadingState: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setHerdModulesLoadingState">, setHerdModulesLoadedInMs: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setHerdModulesLoadedInMs">, setHerdModulesApiDuration: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setHerdModulesApiDuration">, setUserApiDuration: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setUserApiDuration">, setDataProcessingDuration: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setDataProcessingDuration">, setLocalStorageDuration: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setLocalStorageDuration">, setActiveHerdId: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setActiveHerdId">, setActiveDeviceId: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setActiveDeviceId">, appendEventsToHerdModule: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/appendEventsToHerdModule">, replaceEventsForHerdModule: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/replaceEventsForHerdModule">, updateEventValuesForHerdModule: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/updateEventValuesForHerdModule">, updatePageIndexForHerdModule: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/updatePageIndexForHerdModule">, appendPlansToHerdModule: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/appendPlansToHerdModule">, setUser: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/setUser">, addTag: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/addTag">, deleteTag: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/deleteTag">, updateTag: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/updateTag">, addNewDeviceToHerdModule: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/addNewDeviceToHerdModule">, updateDeviceForHerdModule: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/updateDeviceForHerdModule">, addDevice: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/addDevice">, deleteDevice: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/deleteDevice">, updateDevice: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/updateDevice">, addPlan: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/addPlan">, deletePlan: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/deletePlan">, updatePlan: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/updatePlan">, addSessionToStore: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/addSessionToStore">, deleteSessionFromStore: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/deleteSessionFromStore">, updateSessionInStore: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "scout/updateSessionInStore">;
 declare const _default: import("redux").Reducer<ScoutState>;
 export default _default;

package/dist/store/scout.js

@@ -1,4 +1,5 @@
 import { createSlice } from "@reduxjs/toolkit";
+import { EnumHerdModulesLoadingState } from "../types/herd_module";
 export var EnumScoutStateStatus;
 (function (EnumScoutStateStatus) {
     EnumScoutStateStatus["LOADING"] = "LOADING";
@@ -7,6 +8,13 @@ export var EnumScoutStateStatus;
 const initialState = {
     herd_modules: [],
     status: EnumScoutStateStatus.LOADING,
+    herd_modules_loading_state: EnumHerdModulesLoadingState.NOT_LOADING,
+    herd_modules_loaded_in_ms: null,
+    // Initialize timing variables
+    herd_modules_api_duration_ms: null,
+    user_api_duration_ms: null,
+    data_processing_duration_ms: null,
+    localStorage_duration_ms: null,
     lastRefreshed: 0,
     active_herd_id: null,
     active_device_id: null,
@@ -23,6 +31,24 @@ export const scoutSlice = createSlice({
         setStatus: (state, action) => {
             state.status = action.payload;
         },
+        setHerdModulesLoadingState: (state, action) => {
+            state.herd_modules_loading_state = action.payload;
+        },
+        setHerdModulesLoadedInMs: (state, action) => {
+            state.herd_modules_loaded_in_ms = action.payload;
+        },
+        setHerdModulesApiDuration: (state, action) => {
+            state.herd_modules_api_duration_ms = action.payload;
+        },
+        setUserApiDuration: (state, action) => {
+            state.user_api_duration_ms = action.payload;
+        },
+        setDataProcessingDuration: (state, action) => {
+            state.data_processing_duration_ms = action.payload;
+        },
+        setLocalStorageDuration: (state, action) => {
+            state.localStorage_duration_ms = action.payload;
+        },
         setActiveHerdId: (state, action) => {
             state.active_herd_id = action.payload;
         },
@@ -228,5 +254,5 @@ export const scoutSlice = createSlice({
     },
 });
 // Action creators are generated for each case reducer function
-export const { setHerdModules, setStatus, setActiveHerdId, setActiveDeviceId, appendEventsToHerdModule, replaceEventsForHerdModule, updateEventValuesForHerdModule, updatePageIndexForHerdModule, appendPlansToHerdModule, setUser, addTag, deleteTag, updateTag, addNewDeviceToHerdModule, updateDeviceForHerdModule, addDevice, deleteDevice, updateDevice, addPlan, deletePlan, updatePlan, addSessionToStore, deleteSessionFromStore, updateSessionInStore, } = scoutSlice.actions;
+export const { setHerdModules, setStatus, setHerdModulesLoadingState, setHerdModulesLoadedInMs, setHerdModulesApiDuration, setUserApiDuration, setDataProcessingDuration, setLocalStorageDuration, setActiveHerdId, setActiveDeviceId, appendEventsToHerdModule, replaceEventsForHerdModule, updateEventValuesForHerdModule, updatePageIndexForHerdModule, appendPlansToHerdModule, setUser, addTag, deleteTag, updateTag, addNewDeviceToHerdModule, updateDeviceForHerdModule, addDevice, deleteDevice, updateDevice, addPlan, deletePlan, updatePlan, addSessionToStore, deleteSessionFromStore, updateSessionInStore, } = scoutSlice.actions;
 export default scoutSlice.reducer;

package/dist/types/herd_module.d.ts

@@ -1,5 +1,11 @@
 import { SupabaseClient } from "@supabase/supabase-js";
 import { IDevice, IEventWithTags, IHerd, IPlan, ILayer, IUserAndRole, IZoneWithActions, ISessionWithCoordinates } from "../types/db";
+export declare enum EnumHerdModulesLoadingState {
+    NOT_LOADING = "NOT_LOADING",
+    LOADING = "LOADING",
+    SUCCESSFULLY_LOADED = "SUCCESSFULLY_LOADED",
+    UNSUCCESSFULLY_LOADED = "UNSUCCESSFULLY_LOADED"
+}
 export declare class HerdModule {
     herd: IHerd;
     devices: IDevice[];

package/dist/types/herd_module.js

@@ -10,6 +10,13 @@ import { EnumWebResponse } from "./requests";
 import { server_get_more_zones_and_actions_for_herd } from "../helpers/zones";
 import { server_list_api_keys_batch } from "../api_keys/actions";
 import { getSessionsByHerdId } from "../helpers/sessions";
+export var EnumHerdModulesLoadingState;
+(function (EnumHerdModulesLoadingState) {
+    EnumHerdModulesLoadingState["NOT_LOADING"] = "NOT_LOADING";
+    EnumHerdModulesLoadingState["LOADING"] = "LOADING";
+    EnumHerdModulesLoadingState["SUCCESSFULLY_LOADED"] = "SUCCESSFULLY_LOADED";
+    EnumHerdModulesLoadingState["UNSUCCESSFULLY_LOADED"] = "UNSUCCESSFULLY_LOADED";
+})(EnumHerdModulesLoadingState || (EnumHerdModulesLoadingState = {}));
 export class HerdModule {
     constructor(herd, devices, events, timestamp_last_refreshed, user_roles = null, events_page_index = 0, total_events = 0, total_events_with_filters = 0, labels = [], plans = [], zones = [], sessions = [], layers = []) {
         this.user_roles = null;

package/package.json

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