@adventurelabs/scout-core 1.2.6 → 1.3.1

package/dist/helpers/cache.js

@@ -225,8 +225,10 @@ export class ScoutCache {
         const result = await this.getHerdModules();
         const totalRequests = this.stats.hits + this.stats.misses;
         const hitRate = totalRequests > 0 ? this.stats.hits / totalRequests : 0;
+        // Calculate size based on herd modules count (no longer including events/sessions/artifacts arrays)
+        const size = result.data?.length || 0;
         return {
-            size: result.data?.length || 0,
+            size,
             lastUpdated: result.data ? Date.now() - result.age : 0,
             isStale: result.isStale,
             hitRate: Math.round(hitRate * 100) / 100,

package/dist/helpers/session_summaries.d.ts

@@ -0,0 +1,6 @@
+import { ISessionSummary } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { SupabaseClient } from "@supabase/supabase-js";
+export declare function server_get_session_summaries_by_herd(herd_id: number, client?: SupabaseClient): Promise<IWebResponseCompatible<ISessionSummary>>;
+export declare function server_get_session_summaries_by_device(device_id: number, client?: SupabaseClient): Promise<IWebResponseCompatible<ISessionSummary>>;
+export declare function server_get_session_summaries_with_filters(herd_id?: number, device_id?: number, start_date?: string, end_date?: string, client?: SupabaseClient): Promise<IWebResponseCompatible<ISessionSummary>>;

package/dist/helpers/session_summaries.js

@@ -0,0 +1,51 @@
+"use server";
+import { newServerClient } from "../supabase/server";
+import { IWebResponse, } from "../types/requests";
+export async function server_get_session_summaries_by_herd(herd_id, client) {
+    const supabase = client || (await newServerClient());
+    const { data, error } = await supabase.rpc("get_session_summaries", {
+        start_date_caller: undefined,
+        end_date_caller: undefined,
+        device_id_caller: undefined,
+        herd_id_caller: herd_id,
+    });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("No session summary data returned").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function server_get_session_summaries_by_device(device_id, client) {
+    const supabase = client || (await newServerClient());
+    const { data, error } = await supabase.rpc("get_session_summaries", {
+        start_date_caller: undefined,
+        end_date_caller: undefined,
+        device_id_caller: device_id,
+        herd_id_caller: undefined,
+    });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("No session summary data returned").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+export async function server_get_session_summaries_with_filters(herd_id, device_id, start_date, end_date, client) {
+    const supabase = client || (await newServerClient());
+    const { data, error } = await supabase.rpc("get_session_summaries", {
+        start_date_caller: start_date || undefined,
+        end_date_caller: end_date || undefined,
+        device_id_caller: device_id || undefined,
+        herd_id_caller: herd_id || undefined,
+    });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("No session summary data returned").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}

package/dist/hooks/index.d.ts

@@ -7,3 +7,5 @@ export { useScoutRealtimeTags } from "./useScoutRealtimeTags";
 export { useScoutRealtimeSessions } from "./useScoutRealtimeSessions";
 export { useScoutRealtimePlans } from "./useScoutRealtimePlans";
 export { useScoutRealtimePins } from "./useScoutRealtimePins";
+export { useInfiniteSessionsByHerd, useInfiniteSessionsByDevice, useInfiniteEventsByHerd, useInfiniteEventsByDevice, useInfiniteArtifactsByHerd, useInfiniteArtifactsByDevice, useIntersectionObserver, } from "./useInfiniteQuery";
+export { useLoadingPerformance, useSessionSummariesByHerd, useHasSessionSummaries, } from "../store/hooks";

package/dist/hooks/index.js

@@ -7,3 +7,7 @@ export { useScoutRealtimeTags } from "./useScoutRealtimeTags";
 export { useScoutRealtimeSessions } from "./useScoutRealtimeSessions";
 export { useScoutRealtimePlans } from "./useScoutRealtimePlans";
 export { useScoutRealtimePins } from "./useScoutRealtimePins";
+// RTK Query infinite scroll hooks
+export { useInfiniteSessionsByHerd, useInfiniteSessionsByDevice, useInfiniteEventsByHerd, useInfiniteEventsByDevice, useInfiniteArtifactsByHerd, useInfiniteArtifactsByDevice, useIntersectionObserver, } from "./useInfiniteQuery";
+// Session summaries and performance hooks
+export { useLoadingPerformance, useSessionSummariesByHerd, useHasSessionSummaries, } from "../store/hooks";

package/dist/hooks/useHerdData.d.ts

@@ -0,0 +1,167 @@
+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

@@ -0,0 +1,153 @@
+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/useInfiniteQuery.d.ts

@@ -0,0 +1,24 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { IArtifactWithMediaUrl, ISessionWithCoordinates, IEventAndTagsPrettyLocation } from "../types/db";
+interface UseInfiniteScrollOptions {
+    limit?: number;
+    enabled?: boolean;
+    supabase: SupabaseClient;
+}
+interface InfiniteScrollData<T> {
+    items: T[];
+    isLoading: boolean;
+    isLoadingMore: boolean;
+    hasMore: boolean;
+    loadMore: () => void;
+    refetch: () => void;
+    error: any;
+}
+export declare const useInfiniteSessionsByHerd: (herdId: number, options: UseInfiniteScrollOptions) => InfiniteScrollData<ISessionWithCoordinates>;
+export declare const useInfiniteSessionsByDevice: (deviceId: number, options: UseInfiniteScrollOptions) => InfiniteScrollData<ISessionWithCoordinates>;
+export declare const useInfiniteEventsByHerd: (herdId: number, options: UseInfiniteScrollOptions) => InfiniteScrollData<IEventAndTagsPrettyLocation>;
+export declare const useInfiniteEventsByDevice: (deviceId: number, options: UseInfiniteScrollOptions) => InfiniteScrollData<IEventAndTagsPrettyLocation>;
+export declare const useInfiniteArtifactsByHerd: (herdId: number, options: UseInfiniteScrollOptions) => InfiniteScrollData<IArtifactWithMediaUrl>;
+export declare const useInfiniteArtifactsByDevice: (deviceId: number, options: UseInfiniteScrollOptions) => InfiniteScrollData<IArtifactWithMediaUrl>;
+export declare const useIntersectionObserver: (callback: () => void, options?: IntersectionObserverInit) => import("react").Dispatch<import("react").SetStateAction<Element | null>>;
+export {};