@adventurelabs/scout-core 1.4.67 → 1.4.68

package/dist/providers/ScoutRefreshProvider.d.ts

@@ -2866,6 +2866,7 @@ export declare function useSupabase(): SupabaseClient<Database, "public", "publi
             description: string | null;
             latitude: number | null;
             longitude: number | null;
+            color: string | null;
         };
         embedding_match: {
             id: number | null;

package/dist/types/supabase.d.ts

@@ -2951,6 +2951,7 @@ export type Database = {
                 description: string | null;
                 latitude: number | null;
                 longitude: number | null;
+                color: string | null;
             };
             embedding_match: {
                 id: number | null;

package/package.json

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

package/dist/helpers/components.d.ts

@@ -1,14 +0,0 @@
-import { Database } from "../types/supabase";
-import { IComponent, ComponentInsert } from "../types/db";
-import { IWebResponseCompatible } from "../types/requests";
-import { SupabaseClient } from "@supabase/supabase-js";
-export declare function get_components_by_device_id(client: SupabaseClient<Database>, device_id: number): Promise<IWebResponseCompatible<IComponent[]>>;
-export declare function get_component_by_id(client: SupabaseClient<Database>, component_id: number): Promise<IWebResponseCompatible<IComponent | null>>;
-export declare function get_components_by_serial_number(client: SupabaseClient<Database>, serial_number: string): Promise<IWebResponseCompatible<IComponent[]>>;
-export declare function get_components_by_product_number(client: SupabaseClient<Database>, product_number: string): Promise<IWebResponseCompatible<IComponent[]>>;
-export declare function get_components_by_status(client: SupabaseClient<Database>, status: Database["public"]["Enums"]["component_status"]): Promise<IWebResponseCompatible<IComponent[]>>;
-export declare function create_component(client: SupabaseClient<Database>, newComponent: ComponentInsert): Promise<IWebResponseCompatible<IComponent | null>>;
-export declare function update_component(client: SupabaseClient<Database>, component_id: number, updatedComponent: Partial<ComponentInsert>): Promise<IWebResponseCompatible<IComponent | null>>;
-export declare function delete_component(client: SupabaseClient<Database>, component_id: number): Promise<IWebResponseCompatible<IComponent | null>>;
-export declare function update_component_status(client: SupabaseClient<Database>, component_id: number, status: Database["public"]["Enums"]["component_status"]): Promise<IWebResponseCompatible<IComponent | null>>;
-export declare function get_components_by_certificate_id(client: SupabaseClient<Database>, certificate_id: number): Promise<IWebResponseCompatible<IComponent[]>>;

package/dist/helpers/components.js

@@ -1,155 +0,0 @@
-import { IWebResponse } from "../types/requests";
-export async function get_components_by_device_id(client, device_id) {
-    const { data, error } = await client
-        .from("components")
-        .select("*")
-        .eq("device_id", device_id)
-        .order("created_at", { ascending: false });
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    if (!data) {
-        return IWebResponse.error("No components found for device").to_compatible();
-    }
-    return IWebResponse.success(data).to_compatible();
-}
-export async function get_component_by_id(client, component_id) {
-    const { data, error } = await client
-        .from("components")
-        .select("*")
-        .eq("id", component_id)
-        .single();
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    if (!data) {
-        return IWebResponse.error("Component not found").to_compatible();
-    }
-    return IWebResponse.success(data).to_compatible();
-}
-export async function get_components_by_serial_number(client, serial_number) {
-    const { data, error } = await client
-        .from("components")
-        .select("*")
-        .eq("serial_number", serial_number)
-        .order("created_at", { ascending: false });
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    if (!data) {
-        return IWebResponse.error(`No components found with serial number: ${serial_number}`).to_compatible();
-    }
-    return IWebResponse.success(data).to_compatible();
-}
-export async function get_components_by_product_number(client, product_number) {
-    const { data, error } = await client
-        .from("components")
-        .select("*")
-        .eq("product_number", product_number)
-        .order("created_at", { ascending: false });
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    if (!data) {
-        return IWebResponse.error(`No components found with product number: ${product_number}`).to_compatible();
-    }
-    return IWebResponse.success(data).to_compatible();
-}
-export async function get_components_by_status(client, status) {
-    const { data, error } = await client
-        .from("components")
-        .select("*")
-        .eq("status", status)
-        .order("created_at", { ascending: false });
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    if (!data) {
-        return IWebResponse.error(`No components found with status: ${status}`).to_compatible();
-    }
-    return IWebResponse.success(data).to_compatible();
-}
-export async function create_component(client, newComponent) {
-    // Validate required fields
-    if (!newComponent.device_id) {
-        return IWebResponse.error("Device ID is required").to_compatible();
-    }
-    if (!newComponent.serial_number) {
-        return IWebResponse.error("Serial number is required").to_compatible();
-    }
-    const { data, error } = await client
-        .from("components")
-        .insert([newComponent])
-        .select("*")
-        .single();
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    if (!data) {
-        return IWebResponse.error("Failed to create component").to_compatible();
-    }
-    return IWebResponse.success(data).to_compatible();
-}
-export async function update_component(client, component_id, updatedComponent) {
-    // Remove fields that shouldn't be updated
-    const updateData = { ...updatedComponent };
-    delete updateData.id;
-    delete updateData.created_at;
-    const { data, error } = await client
-        .from("components")
-        .update(updateData)
-        .eq("id", component_id)
-        .select("*")
-        .single();
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    if (!data) {
-        return IWebResponse.error("Component not found or update failed").to_compatible();
-    }
-    return IWebResponse.success(data).to_compatible();
-}
-export async function delete_component(client, component_id) {
-    const { data, error } = await client
-        .from("components")
-        .delete()
-        .eq("id", component_id)
-        .select("*")
-        .single();
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    if (!data) {
-        return IWebResponse.error("Component not found or deletion failed").to_compatible();
-    }
-    return IWebResponse.success(data).to_compatible();
-}
-export async function update_component_status(client, component_id, status) {
-    const { data, error } = await client
-        .from("components")
-        .update({ status })
-        .eq("id", component_id)
-        .select("*")
-        .single();
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    if (!data) {
-        return IWebResponse.error("Component not found or status update failed").to_compatible();
-    }
-    return IWebResponse.success(data).to_compatible();
-}
-export async function get_components_by_certificate_id(client, certificate_id) {
-    const { data, error } = await client
-        .from("components")
-        .select("*")
-        .eq("certificate_id", certificate_id)
-        .order("created_at", { ascending: false });
-    if (error) {
-        return IWebResponse.error(error.message).to_compatible();
-    }
-    if (!data) {
-        return IWebResponse.error(`No components found with certificate ID: ${certificate_id}`).to_compatible();
-    }
-    return IWebResponse.success(data).to_compatible();
-}

package/dist/helpers/operator.d.ts

@@ -1,5 +0,0 @@
-import { IWebResponseCompatible } from "../types/requests";
-import { IOperator } from "../types/db";
-export declare function server_get_operators_by_session_id(sessionId: number): Promise<IWebResponseCompatible<IOperator[]>>;
-export declare function server_get_operators_by_user_id(userId: string): Promise<IWebResponseCompatible<IOperator[]>>;
-export declare function server_get_operators_by_session_id_filtered(sessionId: number, action?: string, timestampAfter?: string): Promise<IWebResponseCompatible<IOperator[]>>;

package/dist/helpers/operator.js

@@ -1,64 +0,0 @@
-"use server";
-import { newServerClient } from "../supabase/server";
-import { EnumWebResponse, IWebResponse, } from "../types/requests";
-// Get operators by session id (server id)
-export async function server_get_operators_by_session_id(sessionId) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("operators")
-        .select("*")
-        .eq("session_id", sessionId)
-        .order("created_at", { ascending: false });
-    if (error) {
-        console.warn("Error fetching operators by session id:", error.message);
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: [],
-        };
-    }
-    return IWebResponse.success(data || []).to_compatible();
-}
-// Get all operators for a specific user
-export async function server_get_operators_by_user_id(userId) {
-    const supabase = await newServerClient();
-    const { data, error } = await supabase
-        .from("operators")
-        .select("*")
-        .eq("user_id", userId)
-        .order("created_at", { ascending: false });
-    if (error) {
-        console.warn("Error fetching operators by user id:", error.message);
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: [],
-        };
-    }
-    return IWebResponse.success(data || []).to_compatible();
-}
-// Get operators by session id with additional filters
-export async function server_get_operators_by_session_id_filtered(sessionId, action, timestampAfter) {
-    const supabase = await newServerClient();
-    let query = supabase
-        .from("operators")
-        .select("*")
-        .eq("session_id", sessionId);
-    // Apply optional filters
-    if (action) {
-        query = query.eq("action", action);
-    }
-    if (timestampAfter) {
-        query = query.gte("timestamp", timestampAfter);
-    }
-    const { data, error } = await query.order("timestamp", { ascending: false });
-    if (error) {
-        console.warn("Error fetching filtered operators by session id:", error.message);
-        return {
-            status: EnumWebResponse.ERROR,
-            msg: error.message,
-            data: [],
-        };
-    }
-    return IWebResponse.success(data || []).to_compatible();
-}

package/dist/hooks/useHerdData.d.ts

@@ -1,167 +0,0 @@
-import { SupabaseClient } from "@supabase/supabase-js";
-import { useInfiniteSessionsByHerd, useInfiniteEventsByHerd, useInfiniteArtifactsByHerd } from "./useInfiniteQuery";
-import { IHerdModule } from "../types/herd_module";
-import { ISessionSummary } from "../types/db";
-interface UseHerdDataOptions {
-    sessionsLimit?: number;
-    eventsLimit?: number;
-    artifactsLimit?: number;
-    enableSessions?: boolean;
-    enableEvents?: boolean;
-    enableArtifacts?: boolean;
-    supabase: SupabaseClient;
-}
-interface UseHerdDataReturn {
-    herdModule: IHerdModule | undefined;
-    herd: IHerdModule["herd"] | undefined;
-    devices: IHerdModule["devices"];
-    zones: IHerdModule["zones"];
-    plans: IHerdModule["plans"];
-    layers: IHerdModule["layers"];
-    providers: IHerdModule["providers"];
-    labels: IHerdModule["labels"];
-    userRoles: IHerdModule["user_roles"];
-    sessionSummaries: ISessionSummary | null;
-    timestampLastRefreshed: number | null;
-    sessions: {
-        items: ReturnType<typeof useInfiniteSessionsByHerd>["items"];
-        isLoading: boolean;
-        isLoadingMore: boolean;
-        hasMore: boolean;
-        loadMore: () => void;
-        refetch: () => void;
-        error: any;
-    };
-    events: {
-        items: ReturnType<typeof useInfiniteEventsByHerd>["items"];
-        isLoading: boolean;
-        isLoadingMore: boolean;
-        hasMore: boolean;
-        loadMore: () => void;
-        refetch: () => void;
-        error: any;
-    };
-    artifacts: {
-        items: ReturnType<typeof useInfiniteArtifactsByHerd>["items"];
-        isLoading: boolean;
-        isLoadingMore: boolean;
-        hasMore: boolean;
-        loadMore: () => void;
-        refetch: () => void;
-        error: any;
-    };
-    isInitialLoading: boolean;
-    hasAnyError: boolean;
-}
-/**
- * Comprehensive hook for accessing herd data from both global store and RTK Query
- *
- * @param herdId - The herd ID to fetch data for
- * @param options - Configuration options for data fetching
- * @returns Complete herd data with both structural and paginated content
- *
- * @example
- * ```tsx
- * const {
- *   herd,
- *   devices,
- *   events,
- *   sessions,
- *   artifacts,
- *   sessionSummaries
- * } = useHerdData(123, {
- *   supabase,
- *   eventsLimit: 20,
- *   enableSessions: true
- * });
- *
- * // Use structural data from global store
- * console.log(herd.name, devices.length);
- *
- * // Use paginated data from RTK Query
- * console.log(events.items.length, events.hasMore);
- * if (events.hasMore) {
- *   events.loadMore();
- * }
- *
- * // Use session summaries
- * console.log(sessionSummaries?.total_sessions, sessionSummaries?.total_distance_meters);
- * ```
- */
-export declare const useHerdData: (herdId: number, options: UseHerdDataOptions) => UseHerdDataReturn;
-/**
- * Hook for getting just the structural herd data from global store
- * Useful when you only need basic herd info without paginated content
- */
-export declare const useHerdStructure: (herdId: number) => {
-    herdModule: IHerdModule | undefined;
-    herd: {
-        created_by: string;
-        description: string;
-        earthranger_domain: string | null;
-        earthranger_token: string | null;
-        id: number;
-        inserted_at: string;
-        is_public: boolean;
-        slug: string;
-        video_publisher_token: string | null;
-        video_server_url: string | null;
-        video_subscriber_token: string | null;
-    } | undefined;
-    devices: import("../types/db").IDevice[];
-    zones: import("../types/db").IZoneWithActions[];
-    plans: {
-        herd_id: number;
-        id: number;
-        inserted_at: string | null;
-        instructions: string;
-        name: string;
-        plan_type: import("..").Database["public"]["Enums"]["plan_type"];
-    }[];
-    layers: {
-        created_at: string;
-        features: import("..").Json;
-        herd_id: number;
-        id: number;
-    }[];
-    providers: {
-        created_at: string;
-        herd_id: number;
-        id: number;
-        key: string | null;
-        source: string;
-        type: string;
-    }[];
-    labels: string[];
-    userRoles: import("../types/db").IUserAndRole[] | null;
-    sessionSummaries: ISessionSummary | null;
-    timestampLastRefreshed: number | null;
-};
-/**
- * Hook for getting all herd structures (without paginated data)
- * Useful for dashboard/overview components
- */
-export declare const useAllHerds: () => {
-    herdModules: IHerdModule[];
-    herds: {
-        created_by: string;
-        description: string;
-        earthranger_domain: string | null;
-        earthranger_token: string | null;
-        id: number;
-        inserted_at: string;
-        is_public: boolean;
-        slug: string;
-        video_publisher_token: string | null;
-        video_server_url: string | null;
-        video_subscriber_token: string | null;
-    }[];
-    totalHerds: number;
-    totalDevices: number;
-    sessionSummaries: {
-        herdId: number;
-        herdSlug: string;
-        summaries: ISessionSummary | null;
-    }[];
-};
-export {};

package/dist/hooks/useHerdData.js

@@ -1,153 +0,0 @@
-import { useSelector } from "react-redux";
-import { useInfiniteSessionsByHerd, useInfiniteEventsByHerd, useInfiniteArtifactsByHerd, } from "./useInfiniteQuery";
-/**
- * Comprehensive hook for accessing herd data from both global store and RTK Query
- *
- * @param herdId - The herd ID to fetch data for
- * @param options - Configuration options for data fetching
- * @returns Complete herd data with both structural and paginated content
- *
- * @example
- * ```tsx
- * const {
- *   herd,
- *   devices,
- *   events,
- *   sessions,
- *   artifacts,
- *   sessionSummaries
- * } = useHerdData(123, {
- *   supabase,
- *   eventsLimit: 20,
- *   enableSessions: true
- * });
- *
- * // Use structural data from global store
- * console.log(herd.name, devices.length);
- *
- * // Use paginated data from RTK Query
- * console.log(events.items.length, events.hasMore);
- * if (events.hasMore) {
- *   events.loadMore();
- * }
- *
- * // Use session summaries
- * console.log(sessionSummaries?.total_sessions, sessionSummaries?.total_distance_meters);
- * ```
- */
-export const useHerdData = (herdId, options) => {
-    const { sessionsLimit = 20, eventsLimit = 20, artifactsLimit = 20, enableSessions = true, enableEvents = true, enableArtifacts = true, supabase, } = options;
-    // Get structural data from global store
-    const herdModule = useSelector((state) => state.scout.herd_modules.find((hm) => hm.herd.id === herdId));
-    // RTK Query infinite data hooks
-    const sessionsQuery = useInfiniteSessionsByHerd(herdId, {
-        limit: sessionsLimit,
-        enabled: enableSessions,
-        supabase,
-    });
-    const eventsQuery = useInfiniteEventsByHerd(herdId, {
-        limit: eventsLimit,
-        enabled: enableEvents,
-        supabase,
-    });
-    const artifactsQuery = useInfiniteArtifactsByHerd(herdId, {
-        limit: artifactsLimit,
-        enabled: enableArtifacts,
-        supabase,
-    });
-    // Overall loading state - true if any enabled query is loading for the first time
-    const isInitialLoading = (enableSessions &&
-        sessionsQuery.isLoading &&
-        sessionsQuery.items.length === 0) ||
-        (enableEvents && eventsQuery.isLoading && eventsQuery.items.length === 0) ||
-        (enableArtifacts &&
-            artifactsQuery.isLoading &&
-            artifactsQuery.items.length === 0);
-    // Overall error state - true if any enabled query has an error
-    const hasAnyError = (enableSessions && !!sessionsQuery.error) ||
-        (enableEvents && !!eventsQuery.error) ||
-        (enableArtifacts && !!artifactsQuery.error);
-    return {
-        // Global store structural data
-        herdModule,
-        herd: herdModule?.herd,
-        devices: herdModule?.devices || [],
-        zones: herdModule?.zones || [],
-        plans: herdModule?.plans || [],
-        layers: herdModule?.layers || [],
-        providers: herdModule?.providers || [],
-        labels: herdModule?.labels || [],
-        userRoles: herdModule?.user_roles || null,
-        sessionSummaries: herdModule?.session_summaries || null,
-        timestampLastRefreshed: herdModule?.timestamp_last_refreshed || null,
-        // RTK Query paginated data
-        sessions: {
-            items: sessionsQuery.items,
-            isLoading: sessionsQuery.isLoading,
-            isLoadingMore: sessionsQuery.isLoadingMore,
-            hasMore: sessionsQuery.hasMore,
-            loadMore: sessionsQuery.loadMore,
-            refetch: sessionsQuery.refetch,
-            error: sessionsQuery.error,
-        },
-        events: {
-            items: eventsQuery.items,
-            isLoading: eventsQuery.isLoading,
-            isLoadingMore: eventsQuery.isLoadingMore,
-            hasMore: eventsQuery.hasMore,
-            loadMore: eventsQuery.loadMore,
-            refetch: eventsQuery.refetch,
-            error: eventsQuery.error,
-        },
-        artifacts: {
-            items: artifactsQuery.items,
-            isLoading: artifactsQuery.isLoading,
-            isLoadingMore: artifactsQuery.isLoadingMore,
-            hasMore: artifactsQuery.hasMore,
-            loadMore: artifactsQuery.loadMore,
-            refetch: artifactsQuery.refetch,
-            error: artifactsQuery.error,
-        },
-        // Overall states
-        isInitialLoading,
-        hasAnyError,
-    };
-};
-/**
- * Hook for getting just the structural herd data from global store
- * Useful when you only need basic herd info without paginated content
- */
-export const useHerdStructure = (herdId) => {
-    const herdModule = useSelector((state) => state.scout.herd_modules.find((hm) => hm.herd.id === herdId));
-    return {
-        herdModule,
-        herd: herdModule?.herd,
-        devices: herdModule?.devices || [],
-        zones: herdModule?.zones || [],
-        plans: herdModule?.plans || [],
-        layers: herdModule?.layers || [],
-        providers: herdModule?.providers || [],
-        labels: herdModule?.labels || [],
-        userRoles: herdModule?.user_roles || null,
-        sessionSummaries: herdModule?.session_summaries || null,
-        timestampLastRefreshed: herdModule?.timestamp_last_refreshed || null,
-    };
-};
-/**
- * Hook for getting all herd structures (without paginated data)
- * Useful for dashboard/overview components
- */
-export const useAllHerds = () => {
-    const herdModules = useSelector((state) => state.scout.herd_modules);
-    return {
-        herdModules,
-        herds: herdModules.map((hm) => hm.herd),
-        totalHerds: herdModules.length,
-        totalDevices: herdModules.reduce((sum, hm) => sum + hm.devices.length, 0),
-        sessionSummaries: herdModules.map((hm) => ({
-            herdId: hm.herd.id,
-            herdSlug: hm.herd.slug,
-            summaries: hm.session_summaries,
-        })),
-    };
-};

package/dist/hooks/useScoutBrowserClient.d.ts

@@ -1,11 +0,0 @@
-import { SupabaseClient } from "@supabase/supabase-js";
-import { Database } from "../types/supabase";
-/**
- * Creates one browser Supabase client (reads NEXT_PUBLIC_* env each call).
- * Prefer {@link useScoutBrowserClient} in components so creation runs once via lazy state init.
- */
-export declare function createScoutBrowserClient(): SupabaseClient<Database>;
-/**
- * One browser Supabase client per component instance, created on first render (lazy state initializer).
- */
-export declare function useScoutBrowserClient(): SupabaseClient<Database>;

package/dist/hooks/useScoutBrowserClient.js

@@ -1,17 +0,0 @@
-"use client";
-import { useState } from "react";
-import { createBrowserClient } from "@supabase/ssr";
-/**
- * Creates one browser Supabase client (reads NEXT_PUBLIC_* env each call).
- * Prefer {@link useScoutBrowserClient} in components so creation runs once via lazy state init.
- */
-export function createScoutBrowserClient() {
-    return createBrowserClient(process.env.NEXT_PUBLIC_SUPABASE_URL || "", process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY || "");
-}
-/**
- * One browser Supabase client per component instance, created on first render (lazy state initializer).
- */
-export function useScoutBrowserClient() {
-    const [client] = useState(createScoutBrowserClient);
-    return client;
-}

package/dist/hooks/useScoutDbListener.d.ts

@@ -1,3 +0,0 @@
-import { SupabaseClient } from "@supabase/supabase-js";
-import { Database } from "../types/supabase";
-export declare function useScoutDbListener(scoutSupabase: SupabaseClient<Database>): void;

package/dist/hooks/useScoutDbListener.js

@@ -1,134 +0,0 @@
-"use client";
-import { useAppDispatch } from "../store/hooks";
-import { useEffect, useRef } from "react";
-import { addDevice, addPlan, addTag, addSessionToStore, deleteDevice, deletePlan, deleteSessionFromStore, deleteTag, updateDevice, updatePlan, updateSessionInStore, updateTag, } from "../store/scout";
-export function useScoutDbListener(scoutSupabase) {
-    const supabase = useRef(null);
-    const channels = useRef([]);
-    const dispatch = useAppDispatch();
-    function handleTagInserts(payload) {
-        console.log("[DB Listener] Tag INSERT received:", payload.new);
-        dispatch(addTag(payload.new));
-    }
-    function handleTagDeletes(payload) {
-        console.log("[DB Listener] Tag DELETE received:", payload.old);
-        if (!payload.old || !payload.old.id) {
-            console.error("[DB Listener] Tag DELETE - Invalid payload, missing tag data");
-            return;
-        }
-        dispatch(deleteTag(payload.old));
-    }
-    function handleTagUpdates(payload) {
-        console.log("[DB Listener] Tag UPDATE received:", payload.new);
-        dispatch(updateTag(payload.new));
-    }
-    function handleDeviceInserts(payload) {
-        console.log("[DB Listener] Device INSERT received:", payload.new);
-        dispatch(addDevice(payload.new));
-    }
-    function handleDeviceDeletes(payload) {
-        console.log("[DB Listener] Device DELETE received:", payload.old);
-        dispatch(deleteDevice(payload.old));
-    }
-    function handleDeviceUpdates(payload) {
-        console.log("[DB Listener] Device UPDATE received:", payload.new);
-        dispatch(updateDevice(payload.new));
-    }
-    function handlePlanInserts(payload) {
-        console.log("[DB Listener] Plan INSERT received:", payload.new);
-        dispatch(addPlan(payload.new));
-    }
-    function handlePlanDeletes(payload) {
-        console.log("[DB Listener] Plan DELETE received:", payload.old);
-        dispatch(deletePlan(payload.old));
-    }
-    function handlePlanUpdates(payload) {
-        console.log("[DB Listener] Plan UPDATE received:", payload.new);
-        dispatch(updatePlan(payload.new));
-    }
-    function handleSessionInserts(payload) {
-        console.log("[DB Listener] Session INSERT received:", payload.new);
-        dispatch(addSessionToStore(payload.new));
-    }
-    function handleSessionDeletes(payload) {
-        console.log("[DB Listener] Session DELETE received:", payload.old);
-        if (!payload.old || !payload.old.id) {
-            console.error("[DB Listener] Session DELETE - Invalid payload, missing session data");
-            return;
-        }
-        dispatch(deleteSessionFromStore(payload.old));
-    }
-    function handleSessionUpdates(payload) {
-        console.log("[DB Listener] Session UPDATE received:", payload.new);
-        dispatch(updateSessionInStore(payload.new));
-    }
-    function handleConnectivityInserts(payload) {
-        console.log("[DB Listener] Connectivity INSERT received:", payload.new);
-    }
-    function handleConnectivityDeletes(payload) {
-        console.log("[DB Listener] Connectivity DELETE received:", payload.old);
-    }
-    function handleConnectivityUpdates(payload) {
-        console.log("[DB Listener] Connectivity UPDATE received:", payload.new);
-    }
-    // Clean up all channels
-    const cleanupChannels = () => {
-        channels.current.forEach((channel) => {
-            if (channel) {
-                scoutSupabase.removeChannel(channel);
-            }
-        });
-        channels.current = [];
-    };
-    // Setup channel with event handlers
-    const setupChannel = () => {
-        if (!scoutSupabase)
-            return null;
-        const channelId = `scout_realtime_${Date.now()}_${Math.random()
-            .toString(36)
-            .substr(2, 9)}`;
-        const mainChannel = scoutSupabase.channel(channelId);
-        console.log(`[DB Listener] Creating channel: ${channelId}`);
-        // Subscribe to all events
-        mainChannel
-            .on("postgres_changes", { event: "INSERT", schema: "public", table: "plans" }, handlePlanInserts)
-            .on("postgres_changes", { event: "DELETE", schema: "public", table: "plans" }, handlePlanDeletes)
-            .on("postgres_changes", { event: "UPDATE", schema: "public", table: "plans" }, handlePlanUpdates)
-            .on("postgres_changes", { event: "INSERT", schema: "public", table: "devices" }, handleDeviceInserts)
-            .on("postgres_changes", { event: "DELETE", schema: "public", table: "devices" }, handleDeviceDeletes)
-            .on("postgres_changes", { event: "UPDATE", schema: "public", table: "devices" }, handleDeviceUpdates)
-            .on("postgres_changes", { event: "INSERT", schema: "public", table: "tags" }, handleTagInserts)
-            .on("postgres_changes", { event: "DELETE", schema: "public", table: "tags" }, handleTagDeletes)
-            .on("postgres_changes", { event: "UPDATE", schema: "public", table: "tags" }, handleTagUpdates)
-            .on("postgres_changes", { event: "INSERT", schema: "public", table: "connectivity" }, handleConnectivityInserts)
-            .on("postgres_changes", { event: "DELETE", schema: "public", table: "connectivity" }, handleConnectivityDeletes)
-            .on("postgres_changes", { event: "UPDATE", schema: "public", table: "connectivity" }, handleConnectivityUpdates)
-            .on("postgres_changes", { event: "INSERT", schema: "public", table: "sessions" }, handleSessionInserts)
-            .on("postgres_changes", { event: "DELETE", schema: "public", table: "sessions" }, handleSessionDeletes)
-            .on("postgres_changes", { event: "UPDATE", schema: "public", table: "sessions" }, handleSessionUpdates)
-            .subscribe((status) => {
-            console.log("[DB Listener] Subscription status:", status);
-            if (status === "SUBSCRIBED") {
-                console.log("[DB Listener] ✅ Successfully subscribed to real-time updates");
-            }
-        });
-        return mainChannel;
-    };
-    useEffect(() => {
-        if (!scoutSupabase) {
-            console.error("[DB Listener] No Supabase client available");
-            return;
-        }
-        supabase.current = scoutSupabase;
-        // Initial channel setup
-        const mainChannel = setupChannel();
-        if (mainChannel) {
-            channels.current.push(mainChannel);
-        }
-        // Cleanup function
-        return () => {
-            console.log("[DB Listener] 🧹 Cleaning up channels");
-            cleanupChannels();
-        };
-    }, [scoutSupabase, dispatch]);
-}

package/dist/hooks/useScoutRealtimeConnectivity copy.d.ts

@@ -1,3 +0,0 @@
-import { SupabaseClient } from "@supabase/supabase-js";
-import { Database } from "../types/supabase";
-export declare function useScoutRealtimeConnectivity(scoutSupabase: SupabaseClient<Database>): void;

package/dist/hooks/useScoutRealtimeConnectivity copy.js

@@ -1,159 +0,0 @@
-"use client";
-import { useAppDispatch } from "../store/hooks";
-import { useSelector } from "react-redux";
-import { useEffect, useRef, useCallback, useMemo } from "react";
-import { setActiveHerdGpsTrackersConnectivity } from "../store/scout";
-import { server_get_connectivity_by_device_id } from "../helpers/connectivity";
-import { EnumWebResponse } from "../types/requests";
-import { getHoursAgoTimestamp } from "../helpers/time";
-export function useScoutRealtimeConnectivity(scoutSupabase) {
-    const channels = useRef([]);
-    const dispatch = useAppDispatch();
-    const activeHerdId = useSelector((state) => state.scout.active_herd_id);
-    const connectivity = useSelector((state) => state.scout.active_herd_gps_trackers_connectivity);
-    const herdModules = useSelector((state) => state.scout.herd_modules);
-    // Create stable reference for GPS device IDs to prevent unnecessary refetching
-    const gpsDeviceIds = useMemo(() => {
-        if (!activeHerdId)
-            return "";
-        const activeHerdModule = herdModules.find((hm) => hm.herd.id.toString() === activeHerdId);
-        if (!activeHerdModule)
-            return "";
-        const gpsDevices = activeHerdModule.devices.filter((device) => device.device_type &&
-            ["gps_tracker", "gps_tracker_vehicle", "gps_tracker_person"].includes(device.device_type));
-        return gpsDevices
-            .map((d) => d.id)
-            .filter(Boolean)
-            .sort()
-            .join(",");
-    }, [activeHerdId, herdModules]);
-    // Handle connectivity broadcasts
-    const handleConnectivityBroadcast = useCallback((payload) => {
-        const { event, payload: data } = payload;
-        const connectivityData = data.record || data.old_record;
-        // Only process GPS tracker data (no session_id)
-        if (!connectivityData?.device_id || connectivityData.session_id) {
-            return;
-        }
-        const deviceId = connectivityData.device_id;
-        const updatedConnectivity = { ...connectivity };
-        switch (data.operation) {
-            case "INSERT":
-                console.log(`[CONNECTIVITY] INSERT for ${deviceId}, ${JSON.stringify(connectivityData)}`);
-                if (!updatedConnectivity[deviceId]) {
-                    updatedConnectivity[deviceId] = {
-                        most_recent: connectivityData,
-                        history: [],
-                    };
-                }
-                else {
-                    const newHistory = [
-                        updatedConnectivity[deviceId].most_recent,
-                        ...updatedConnectivity[deviceId].history,
-                    ].slice(0, 99);
-                    updatedConnectivity[deviceId] = {
-                        most_recent: connectivityData,
-                        history: newHistory,
-                    };
-                }
-                break;
-            case "UPDATE":
-                if (updatedConnectivity[deviceId]) {
-                    if (updatedConnectivity[deviceId].most_recent.id ===
-                        connectivityData.id) {
-                        updatedConnectivity[deviceId] = {
-                            ...updatedConnectivity[deviceId],
-                            most_recent: connectivityData,
-                        };
-                    }
-                    else {
-                        const historyIndex = updatedConnectivity[deviceId].history.findIndex((c) => c.id === connectivityData.id);
-                        if (historyIndex >= 0) {
-                            const newHistory = [...updatedConnectivity[deviceId].history];
-                            newHistory[historyIndex] = connectivityData;
-                            updatedConnectivity[deviceId] = {
-                                ...updatedConnectivity[deviceId],
-                                history: newHistory,
-                            };
-                        }
-                    }
-                }
-                break;
-            case "DELETE":
-                if (updatedConnectivity[deviceId]) {
-                    if (updatedConnectivity[deviceId].most_recent.id ===
-                        connectivityData.id) {
-                        if (updatedConnectivity[deviceId].history.length === 0) {
-                            delete updatedConnectivity[deviceId];
-                        }
-                        else {
-                            updatedConnectivity[deviceId] = {
-                                most_recent: updatedConnectivity[deviceId].history[0],
-                                history: updatedConnectivity[deviceId].history.slice(1),
-                            };
-                        }
-                    }
-                    else {
-                        updatedConnectivity[deviceId] = {
-                            ...updatedConnectivity[deviceId],
-                            history: updatedConnectivity[deviceId].history.filter((c) => c.id !== connectivityData.id),
-                        };
-                    }
-                }
-                break;
-        }
-        dispatch(setActiveHerdGpsTrackersConnectivity(updatedConnectivity));
-    }, [connectivity, dispatch]);
-    // Fetch initial connectivity data
-    const fetchInitialData = useCallback(async () => {
-        if (!gpsDeviceIds)
-            return;
-        const deviceIds = gpsDeviceIds.split(",").filter(Boolean).map(Number);
-        if (deviceIds.length === 0) {
-            return;
-        }
-        const timestampFilter = getHoursAgoTimestamp(1);
-        const connectivityData = {};
-        await Promise.all(deviceIds.map(async (deviceId) => {
-            try {
-                const response = await server_get_connectivity_by_device_id(deviceId, timestampFilter);
-                if (response.status === EnumWebResponse.SUCCESS && response.data) {
-                    const trackerData = response.data.filter((conn) => !conn.session_id);
-                    if (trackerData.length > 0) {
-                        const sortedData = trackerData
-                            .sort((a, b) => new Date(b.timestamp_start || 0).getTime() -
-                            new Date(a.timestamp_start || 0).getTime())
-                            .slice(0, 100);
-                        connectivityData[deviceId] = {
-                            most_recent: sortedData[0],
-                            history: sortedData.slice(1), // Exclude the most recent item
-                        };
-                    }
-                }
-            }
-            catch (error) {
-                // Silent error handling
-            }
-        }));
-        dispatch(setActiveHerdGpsTrackersConnectivity(connectivityData));
-    }, [gpsDeviceIds, dispatch]);
-    useEffect(() => {
-        if (!scoutSupabase || gpsDeviceIds === "")
-            return;
-        // Clean up existing channels
-        channels.current.forEach((channel) => scoutSupabase.removeChannel(channel));
-        channels.current = [];
-        // Create connectivity channel
-        const channel = scoutSupabase
-            .channel(`${activeHerdId}-connectivity`, { config: { private: true } })
-            .on("broadcast", { event: "*" }, handleConnectivityBroadcast)
-            .subscribe();
-        channels.current.push(channel);
-        // Fetch initial data
-        fetchInitialData();
-        return () => {
-            channels.current.forEach((ch) => scoutSupabase.removeChannel(ch));
-            channels.current = [];
-        };
-    }, [scoutSupabase, gpsDeviceIds, activeHerdId, handleConnectivityBroadcast]);
-}

package/dist/hooks/useScoutRealtimeDevices copy.d.ts

@@ -1,3 +0,0 @@
-import { SupabaseClient } from "@supabase/supabase-js";
-import { Database } from "../types/supabase";
-export declare function useScoutRealtimeDevices(scoutSupabase: SupabaseClient<Database>): void;

package/dist/hooks/useScoutRealtimeDevices copy.js

@@ -1,55 +0,0 @@
-"use client";
-import { useAppDispatch } from "../store/hooks";
-import { useSelector } from "react-redux";
-import { useEffect, useRef, useCallback } from "react";
-import { addDevice, deleteDevice, updateDevice } from "../store/scout";
-export function useScoutRealtimeDevices(scoutSupabase) {
-    const channels = useRef([]);
-    const dispatch = useAppDispatch();
-    const activeHerdId = useSelector((state) => state.scout.active_herd_id);
-    // Device broadcast handler
-    const handleDeviceBroadcast = useCallback((payload) => {
-        console.log("[Devices] Broadcast received:", payload.payload.operation);
-        const data = payload.payload;
-        switch (data.operation) {
-            case "INSERT":
-                if (data.record)
-                    dispatch(addDevice(data.record));
-                break;
-            case "UPDATE":
-                if (data.record)
-                    dispatch(updateDevice(data.record));
-                break;
-            case "DELETE":
-                if (data.old_record)
-                    dispatch(deleteDevice(data.old_record));
-                break;
-        }
-    }, [dispatch]);
-    const cleanupChannels = () => {
-        channels.current.forEach((channel) => scoutSupabase.removeChannel(channel));
-        channels.current = [];
-    };
-    const createDevicesChannel = (herdId) => {
-        return scoutSupabase
-            .channel(`${herdId}-devices`, { config: { private: true } })
-            .on("broadcast", { event: "*" }, handleDeviceBroadcast)
-            .subscribe((status) => {
-            if (status === "SUBSCRIBED") {
-                console.log(`[Devices] ✅ Connected to herd ${herdId}`);
-            }
-            else if (status === "CHANNEL_ERROR") {
-                console.warn(`[Devices] 🟡 Failed to connect to herd ${herdId}`);
-            }
-        });
-    };
-    useEffect(() => {
-        cleanupChannels();
-        // Create devices channel for active herd
-        if (activeHerdId) {
-            const channel = createDevicesChannel(activeHerdId);
-            channels.current.push(channel);
-        }
-        return cleanupChannels;
-    }, [activeHerdId]);
-}

package/dist/types/data.d.ts

@@ -1,4 +0,0 @@
-export type HistoricalData<T> = {
-    most_recent: T;
-    history: T[];
-};

package/dist/types/data.js

@@ -1 +0,0 @@
-export {};