@adventurelabs/scout-core 1.2.1 → 1.2.2

package/dist/hooks/index.d.ts

@@ -2,3 +2,7 @@ export { useScoutRefresh, type UseScoutRefreshOptions, } from "./useScoutRefresh
 export { useScoutRealtimeConnectivity } from "./useScoutRealtimeConnectivity";
 export { useScoutRealtimeDevices } from "./useScoutRealtimeDevices";
 export { useScoutRealtimeVersionsSoftware } from "./useScoutRealtimeVersionsSoftware";
+export { useScoutRealtimeEvents } from "./useScoutRealtimeEvents";
+export { useScoutRealtimeTags } from "./useScoutRealtimeTags";
+export { useScoutRealtimeSessions } from "./useScoutRealtimeSessions";
+export { useScoutRealtimePlans } from "./useScoutRealtimePlans";

package/dist/hooks/index.js

@@ -2,3 +2,7 @@ export { useScoutRefresh, } from "./useScoutRefresh";
 export { useScoutRealtimeConnectivity } from "./useScoutRealtimeConnectivity";
 export { useScoutRealtimeDevices } from "./useScoutRealtimeDevices";
 export { useScoutRealtimeVersionsSoftware } from "./useScoutRealtimeVersionsSoftware";
+export { useScoutRealtimeEvents } from "./useScoutRealtimeEvents";
+export { useScoutRealtimeTags } from "./useScoutRealtimeTags";
+export { useScoutRealtimeSessions } from "./useScoutRealtimeSessions";
+export { useScoutRealtimePlans } from "./useScoutRealtimePlans";

package/dist/hooks/useScoutRealtimeEvents.d.ts

@@ -0,0 +1,5 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { Database } from "../types/supabase";
+import { IEventAndTagsPrettyLocation } from "../types/db";
+import { RealtimeData } from "../types/realtime";
+export declare function useScoutRealtimeEvents(scoutSupabase: SupabaseClient<Database>, shouldUpdateGlobalStateOnChanges: boolean): RealtimeData<IEventAndTagsPrettyLocation>[];

package/dist/hooks/useScoutRealtimeEvents.js

@@ -0,0 +1,96 @@
+"use client";
+import { useAppDispatch } from "../store/hooks";
+import { useSelector } from "react-redux";
+import { useEffect, useRef, useCallback, useState } from "react";
+import { updateEventValuesForHerdModule } from "../store/scout";
+import { EnumRealtimeOperation } from "../types/realtime";
+export function useScoutRealtimeEvents(scoutSupabase, shouldUpdateGlobalStateOnChanges) {
+    const channels = useRef([]);
+    const dispatch = useAppDispatch();
+    const [newEventItems, setNewEventItems] = useState([]);
+    const activeHerdId = useSelector((state) => state.scout.active_herd_id);
+    // Event broadcast handler
+    const handleEventBroadcast = useCallback((payload) => {
+        console.log("[Events] Broadcast received:", payload.payload.operation);
+        const data = payload.payload;
+        const eventData = data.record || data.old_record;
+        if (!eventData)
+            return;
+        let operation;
+        // TODO: UNCOMMENT GLOBAL STORE OPERATIONS IF OKAY WITH FREQUENT
+        switch (data.operation) {
+            case "INSERT":
+                operation = EnumRealtimeOperation.INSERT;
+                if (data.record && activeHerdId && shouldUpdateGlobalStateOnChanges) {
+                    console.log("[Events] New event received:", data.record);
+                    // For events, we need to update the event values in the herd module
+                    dispatch(updateEventValuesForHerdModule({
+                        herd_id: activeHerdId,
+                        events: [data.record],
+                    }));
+                }
+                break;
+            case "UPDATE":
+                operation = EnumRealtimeOperation.UPDATE;
+                if (data.record && activeHerdId && shouldUpdateGlobalStateOnChanges) {
+                    console.log("[Events] Event updated:", data.record);
+                    dispatch(updateEventValuesForHerdModule({
+                        herd_id: activeHerdId,
+                        events: [data.record],
+                    }));
+                }
+                break;
+            case "DELETE":
+                operation = EnumRealtimeOperation.DELETE;
+                if (data.old_record &&
+                    activeHerdId &&
+                    shouldUpdateGlobalStateOnChanges) {
+                    console.log("[Events] Event deleted:", data.old_record);
+                    // TODO: WRITE DELETION STORE ACTION
+                    console.log("[Events] Event deletion detected - manual refresh may be needed");
+                }
+                break;
+            default:
+                return;
+        }
+        const realtimeData = {
+            data: eventData,
+            operation,
+        };
+        console.log(`[scout-core realtime] EVENT ${data.operation} received:`, JSON.stringify(realtimeData));
+        setNewEventItems((prev) => [realtimeData, ...prev]);
+    }, [dispatch, activeHerdId]);
+    // Clear new items when herd changes
+    const clearNewItems = useCallback(() => {
+        setNewEventItems([]);
+    }, []);
+    const cleanupChannels = () => {
+        channels.current.forEach((channel) => scoutSupabase.removeChannel(channel));
+        channels.current = [];
+    };
+    const createEventsChannel = (herdId) => {
+        return scoutSupabase
+            .channel(`${herdId}-events`, { config: { private: true } })
+            .on("broadcast", { event: "*" }, handleEventBroadcast)
+            .subscribe((status) => {
+            if (status === "SUBSCRIBED") {
+                console.log(`[Events] ✅ Connected to herd ${herdId}`);
+            }
+            else if (status === "CHANNEL_ERROR") {
+                console.warn(`[Events] 🟡 Failed to connect to herd ${herdId}`);
+            }
+        });
+    };
+    useEffect(() => {
+        cleanupChannels();
+        // Clear previous items when switching herds
+        clearNewItems();
+        // Create events channel for active herd
+        if (activeHerdId) {
+            const channel = createEventsChannel(activeHerdId);
+            channels.current.push(channel);
+        }
+        return cleanupChannels;
+    }, [activeHerdId, clearNewItems]);
+    return newEventItems;
+}

package/dist/hooks/useScoutRealtimePlans.d.ts

@@ -0,0 +1,5 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { Database } from "../types/supabase";
+import { IPlan } from "../types/db";
+import { RealtimeData } from "../types/realtime";
+export declare function useScoutRealtimePlans(scoutSupabase: SupabaseClient<Database>, shouldUpdateGlobalStateOnChanges: boolean): RealtimeData<IPlan>[];

package/dist/hooks/useScoutRealtimePlans.js

@@ -0,0 +1,83 @@
+"use client";
+import { useAppDispatch } from "../store/hooks";
+import { useSelector } from "react-redux";
+import { useEffect, useRef, useCallback, useState } from "react";
+import { addPlan, deletePlan, updatePlan } from "../store/scout";
+import { EnumRealtimeOperation } from "../types/realtime";
+export function useScoutRealtimePlans(scoutSupabase, shouldUpdateGlobalStateOnChanges) {
+    const channels = useRef([]);
+    const dispatch = useAppDispatch();
+    const [newPlanItems, setNewPlanItems] = useState([]);
+    const activeHerdId = useSelector((state) => state.scout.active_herd_id);
+    // Plan broadcast handler
+    const handlePlanBroadcast = useCallback((payload) => {
+        console.log("[Plans] Broadcast received:", payload.payload.operation);
+        const data = payload.payload;
+        const planData = data.record || data.old_record;
+        if (!planData)
+            return;
+        let operation;
+        switch (data.operation) {
+            case "INSERT":
+                operation = EnumRealtimeOperation.INSERT;
+                if (data.record && shouldUpdateGlobalStateOnChanges) {
+                    console.log("[Plans] New plan received:", data.record);
+                    dispatch(addPlan(data.record));
+                }
+                break;
+            case "UPDATE":
+                operation = EnumRealtimeOperation.UPDATE;
+                if (data.record && shouldUpdateGlobalStateOnChanges) {
+                    dispatch(updatePlan(data.record));
+                }
+                break;
+            case "DELETE":
+                operation = EnumRealtimeOperation.DELETE;
+                if (data.old_record && shouldUpdateGlobalStateOnChanges) {
+                    dispatch(deletePlan(data.old_record));
+                }
+                break;
+            default:
+                return;
+        }
+        const realtimeData = {
+            data: planData,
+            operation,
+        };
+        console.log(`[scout-core realtime] PLAN ${data.operation} received:`, JSON.stringify(realtimeData));
+        setNewPlanItems((prev) => [realtimeData, ...prev]);
+    }, [dispatch]);
+    // Clear new items when herd changes
+    const clearNewItems = useCallback(() => {
+        setNewPlanItems([]);
+    }, []);
+    const cleanupChannels = () => {
+        channels.current.forEach((channel) => scoutSupabase.removeChannel(channel));
+        channels.current = [];
+    };
+    const createPlansChannel = (herdId) => {
+        return scoutSupabase
+            .channel(`${herdId}-plans`, { config: { private: true } })
+            .on("broadcast", { event: "*" }, handlePlanBroadcast)
+            .subscribe((status) => {
+            if (status === "SUBSCRIBED") {
+                console.log(`[Plans] ✅ Connected to herd ${herdId}`);
+            }
+            else if (status === "CHANNEL_ERROR") {
+                console.warn(`[Plans] 🟡 Failed to connect to herd ${herdId}`);
+            }
+        });
+    };
+    useEffect(() => {
+        cleanupChannels();
+        // Clear previous items when switching herds
+        clearNewItems();
+        // Create plans channel for active herd
+        if (activeHerdId) {
+            const channel = createPlansChannel(activeHerdId);
+            channels.current.push(channel);
+        }
+        return cleanupChannels;
+    }, [activeHerdId, clearNewItems]);
+    return newPlanItems;
+}

package/dist/hooks/useScoutRealtimeSessions.d.ts

@@ -0,0 +1,5 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { Database } from "../types/supabase";
+import { ISessionWithCoordinates } from "../types/db";
+import { RealtimeData } from "../types/realtime";
+export declare function useScoutRealtimeSessions(scoutSupabase: SupabaseClient<Database>, shouldUpdateGlobalStateOnChanges: boolean): RealtimeData<ISessionWithCoordinates>[];

package/dist/hooks/useScoutRealtimeSessions.js

@@ -0,0 +1,83 @@
+"use client";
+import { useAppDispatch } from "../store/hooks";
+import { useSelector } from "react-redux";
+import { useEffect, useRef, useCallback, useState } from "react";
+import { addSessionToStore, deleteSessionFromStore, updateSessionInStore, } from "../store/scout";
+import { EnumRealtimeOperation } from "../types/realtime";
+export function useScoutRealtimeSessions(scoutSupabase, shouldUpdateGlobalStateOnChanges) {
+    const channels = useRef([]);
+    const dispatch = useAppDispatch();
+    const [newSessionItems, setNewSessionItems] = useState([]);
+    const activeHerdId = useSelector((state) => state.scout.active_herd_id);
+    // Session broadcast handler
+    const handleSessionBroadcast = useCallback((payload) => {
+        console.log("[Sessions] Broadcast received:", payload.payload.operation);
+        const data = payload.payload;
+        const sessionData = data.record || data.old_record;
+        if (!sessionData)
+            return;
+        let operation;
+        switch (data.operation) {
+            case "INSERT":
+                operation = EnumRealtimeOperation.INSERT;
+                if (data.record && shouldUpdateGlobalStateOnChanges) {
+                    console.log("[Sessions] New session received:", data.record);
+                    dispatch(addSessionToStore(data.record));
+                }
+                break;
+            case "UPDATE":
+                operation = EnumRealtimeOperation.UPDATE;
+                if (data.record && shouldUpdateGlobalStateOnChanges) {
+                    dispatch(updateSessionInStore(data.record));
+                }
+                break;
+            case "DELETE":
+                operation = EnumRealtimeOperation.DELETE;
+                if (data.old_record && shouldUpdateGlobalStateOnChanges) {
+                    dispatch(deleteSessionFromStore(data.old_record));
+                }
+                break;
+            default:
+                return;
+        }
+        const realtimeData = {
+            data: sessionData,
+            operation,
+        };
+        console.log(`[scout-core realtime] SESSION ${data.operation} received:`, JSON.stringify(realtimeData));
+        setNewSessionItems((prev) => [realtimeData, ...prev]);
+    }, [dispatch]);
+    // Clear new items when herd changes
+    const clearNewItems = useCallback(() => {
+        setNewSessionItems([]);
+    }, []);
+    const cleanupChannels = () => {
+        channels.current.forEach((channel) => scoutSupabase.removeChannel(channel));
+        channels.current = [];
+    };
+    const createSessionsChannel = (herdId) => {
+        return scoutSupabase
+            .channel(`${herdId}-sessions`, { config: { private: true } })
+            .on("broadcast", { event: "*" }, handleSessionBroadcast)
+            .subscribe((status) => {
+            if (status === "SUBSCRIBED") {
+                console.log(`[Sessions] ✅ Connected to herd ${herdId}`);
+            }
+            else if (status === "CHANNEL_ERROR") {
+                console.warn(`[Sessions] 🟡 Failed to connect to herd ${herdId}`);
+            }
+        });
+    };
+    useEffect(() => {
+        cleanupChannels();
+        // Clear previous items when switching herds
+        clearNewItems();
+        // Create sessions channel for active herd
+        if (activeHerdId) {
+            const channel = createSessionsChannel(activeHerdId);
+            channels.current.push(channel);
+        }
+        return cleanupChannels;
+    }, [activeHerdId, clearNewItems]);
+    return newSessionItems;
+}

package/dist/hooks/useScoutRealtimeTags.d.ts

@@ -0,0 +1,5 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { Database } from "../types/supabase";
+import { ITagPrettyLocation } from "../types/db";
+import { RealtimeData } from "../types/realtime";
+export declare function useScoutRealtimeTags(scoutSupabase: SupabaseClient<Database>, shouldUpdateGlobalStateOnChanges: boolean): RealtimeData<ITagPrettyLocation>[];

package/dist/hooks/useScoutRealtimeTags.js

@@ -0,0 +1,85 @@
+"use client";
+import { useAppDispatch } from "../store/hooks";
+import { useSelector } from "react-redux";
+import { useEffect, useRef, useCallback, useState } from "react";
+import { addTag, deleteTag, updateTag } from "../store/scout";
+import { EnumRealtimeOperation } from "../types/realtime";
+export function useScoutRealtimeTags(scoutSupabase, shouldUpdateGlobalStateOnChanges) {
+    const channels = useRef([]);
+    const dispatch = useAppDispatch();
+    const [newTagItems, setNewTagItems] = useState([]);
+    const activeHerdId = useSelector((state) => state.scout.active_herd_id);
+    // Tag broadcast handler
+    const handleTagBroadcast = useCallback((payload) => {
+        console.log("[Tags] Broadcast received:", payload.payload.operation);
+        const data = payload.payload;
+        const tagData = data.record || data.old_record;
+        if (!tagData)
+            return;
+        let operation;
+        switch (data.operation) {
+            case "INSERT":
+                operation = EnumRealtimeOperation.INSERT;
+                if (data.record && shouldUpdateGlobalStateOnChanges) {
+                    console.log("[Tags] New tag received:", data.record);
+                    dispatch(addTag(data.record));
+                }
+                break;
+            case "UPDATE":
+                operation = EnumRealtimeOperation.UPDATE;
+                if (data.record && shouldUpdateGlobalStateOnChanges) {
+                    console.log("[Tags] Tag updated:", data.record);
+                    dispatch(updateTag(data.record));
+                }
+                break;
+            case "DELETE":
+                operation = EnumRealtimeOperation.DELETE;
+                if (data.old_record && shouldUpdateGlobalStateOnChanges) {
+                    console.log("[Tags] Tag deleted:", data.old_record);
+                    dispatch(deleteTag(data.old_record));
+                }
+                break;
+            default:
+                return;
+        }
+        const realtimeData = {
+            data: tagData,
+            operation,
+        };
+        console.log(`[scout-core realtime] TAG ${data.operation} received:`, JSON.stringify(realtimeData));
+        setNewTagItems((prev) => [realtimeData, ...prev]);
+    }, [dispatch]);
+    // Clear new items when herd changes
+    const clearNewItems = useCallback(() => {
+        setNewTagItems([]);
+    }, []);
+    const cleanupChannels = () => {
+        channels.current.forEach((channel) => scoutSupabase.removeChannel(channel));
+        channels.current = [];
+    };
+    const createTagsChannel = (herdId) => {
+        return scoutSupabase
+            .channel(`${herdId}-tags`, { config: { private: true } })
+            .on("broadcast", { event: "*" }, handleTagBroadcast)
+            .subscribe((status) => {
+            if (status === "SUBSCRIBED") {
+                console.log(`[Tags] ✅ Connected to herd ${herdId}`);
+            }
+            else if (status === "CHANNEL_ERROR") {
+                console.warn(`[Tags] 🟡 Failed to connect to herd ${herdId}`);
+            }
+        });
+    };
+    useEffect(() => {
+        cleanupChannels();
+        // Clear previous items when switching herds
+        clearNewItems();
+        // Create tags channel for active herd
+        if (activeHerdId) {
+            const channel = createTagsChannel(activeHerdId);
+            channels.current.push(channel);
+        }
+        return cleanupChannels;
+    }, [activeHerdId, clearNewItems]);
+    return newTagItems;
+}

package/dist/index.d.ts

@@ -41,6 +41,10 @@ export * from "./helpers/components";
 export * from "./hooks/useScoutRealtimeConnectivity";
 export * from "./hooks/useScoutRealtimeDevices";
 export * from "./hooks/useScoutRealtimeVersionsSoftware";
+export * from "./hooks/useScoutRealtimeEvents";
+export * from "./hooks/useScoutRealtimeTags";
+export * from "./hooks/useScoutRealtimeSessions";
+export * from "./hooks/useScoutRealtimePlans";
 export * from "./hooks/useScoutRefresh";
 export * from "./providers";
 export * from "./store/scout";

package/dist/index.js

@@ -45,6 +45,10 @@ export * from "./helpers/components";
 export * from "./hooks/useScoutRealtimeConnectivity";
 export * from "./hooks/useScoutRealtimeDevices";
 export * from "./hooks/useScoutRealtimeVersionsSoftware";
+export * from "./hooks/useScoutRealtimeEvents";
+export * from "./hooks/useScoutRealtimeTags";
+export * from "./hooks/useScoutRealtimeSessions";
+export * from "./hooks/useScoutRealtimePlans";
 export * from "./hooks/useScoutRefresh";
 // Providers
 export * from "./providers";

package/package.json

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