@adventurelabs/scout-core 1.4.17 → 1.4.19

package/dist/helpers/artifacts.d.ts

@@ -1,10 +1,19 @@
 import { IArtifact, IArtifactWithMediaUrl, ArtifactInsert, ArtifactUpdate } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
 import { SupabaseClient } from "@supabase/supabase-js";
-export declare function server_get_artifacts_by_herd(herd_id: number, limit?: number, offset?: number, client?: SupabaseClient): Promise<IWebResponseCompatible<IArtifactWithMediaUrl[]>>;
+export declare function server_get_artifact_by_id(id: number, client?: SupabaseClient): Promise<IWebResponseCompatible<IArtifactWithMediaUrl | null>>;
+export declare function server_get_artifacts_by_herd(herd_id: number, limit?: number, offset?: number, options?: {
+    start_timestamp?: string;
+    end_timestamp?: string;
+    client?: SupabaseClient;
+}): Promise<IWebResponseCompatible<IArtifactWithMediaUrl[]>>;
 export declare function server_get_artifacts_by_device_id(device_id: number, limit?: number, offset?: number, client?: SupabaseClient): Promise<IWebResponseCompatible<IArtifactWithMediaUrl[]>>;
 export declare function server_get_total_artifacts_by_herd(herd_id: number): Promise<IWebResponseCompatible<number>>;
-export declare function server_get_artifacts_by_device_ids_batch(device_ids: number[], limit_per_device?: number, client?: SupabaseClient): Promise<{
+export declare function server_get_artifacts_by_device_ids_batch(device_ids: number[], limit_per_device?: number, options?: {
+    start_timestamp?: string;
+    end_timestamp?: string;
+    client?: SupabaseClient;
+}): Promise<{
     [device_id: number]: IArtifactWithMediaUrl[];
 }>;
 export declare function server_insert_artifact(artifact: ArtifactInsert | ArtifactInsert[], client?: SupabaseClient): Promise<IWebResponseCompatible<IArtifact[]>>;

package/dist/helpers/artifacts.js

@@ -1,13 +1,38 @@
 "use server";
 import { newServerClient } from "../supabase/server";
 import { IWebResponse } from "../types/requests";
-import { generateSignedUrlsBatch } from "./storage";
-export async function server_get_artifacts_by_herd(herd_id, limit = 50, offset = 0, client) {
+import { generateSignedUrlsBatch, generateSignedUrl } from "./storage";
+export async function server_get_artifact_by_id(id, client) {
     const supabase = client || (await newServerClient());
+    const { data, error } = await supabase
+        .from("artifacts")
+        .select("*")
+        .eq("id", id)
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.success(null).to_compatible();
+    }
+    const artifact = data;
+    let media_url = null;
+    if (artifact.file_path) {
+        media_url = await generateSignedUrl(artifact.file_path, undefined, client);
+    }
+    return IWebResponse.success({
+        ...artifact,
+        media_url,
+    }).to_compatible();
+}
+export async function server_get_artifacts_by_herd(herd_id, limit = 50, offset = 0, options) {
+    const supabase = options?.client || (await newServerClient());
     const { data, error } = await supabase.rpc("get_artifacts_for_herd", {
         herd_id_caller: herd_id,
         limit_caller: limit,
         offset_caller: offset,
+        start_timestamp: options?.start_timestamp,
+        end_timestamp: options?.end_timestamp,
     });
     if (error) {
         return IWebResponse.error(error.message).to_compatible();
@@ -22,7 +47,7 @@ export async function server_get_artifacts_by_herd(herd_id, limit = 50, offset =
     if (uniqueFilePaths.length === 0) {
         return IWebResponse.success(data).to_compatible();
     }
-    const signedUrls = await generateSignedUrlsBatch(uniqueFilePaths, undefined, client);
+    const signedUrls = await generateSignedUrlsBatch(uniqueFilePaths, undefined, options?.client);
     const urlMap = new Map();
     uniqueFilePaths.forEach((path, index) => {
         urlMap.set(path, signedUrls[index]);
@@ -78,14 +103,16 @@ export async function server_get_total_artifacts_by_herd(herd_id) {
     }
     return IWebResponse.success(data || 0).to_compatible();
 }
-export async function server_get_artifacts_by_device_ids_batch(device_ids, limit_per_device = 10, client) {
-    const supabase = client || (await newServerClient());
+export async function server_get_artifacts_by_device_ids_batch(device_ids, limit_per_device = 10, options) {
+    const supabase = options?.client || (await newServerClient());
     if (device_ids.length === 0) {
         return {};
     }
     const { data, error } = await supabase.rpc("get_artifacts_for_devices_batch", {
         device_ids: device_ids,
         limit_per_device: limit_per_device,
+        start_timestamp: options?.start_timestamp,
+        end_timestamp: options?.end_timestamp,
     });
     if (error || !data) {
         console.warn("Error fetching artifacts batch:", error?.message);
@@ -97,7 +124,7 @@ export async function server_get_artifacts_by_device_ids_batch(device_ids, limit
         .filter((path) => !!path)));
     let artifactsWithUrls = data;
     if (uniqueFilePaths.length > 0) {
-        const signedUrls = await generateSignedUrlsBatch(uniqueFilePaths, undefined, client);
+        const signedUrls = await generateSignedUrlsBatch(uniqueFilePaths, undefined, options?.client);
         const urlMap = new Map();
         uniqueFilePaths.forEach((path, index) => {
             urlMap.set(path, signedUrls[index]);

package/dist/helpers/bounding_boxes.d.ts

@@ -1,5 +1,5 @@
 import { BoundingBox, EnumSourceBoundingBox } from "../types/bounding_boxes";
-import { Tag } from "../types/db";
-export declare function convertManualBoundingBoxToTag(boundingBox: BoundingBox, event_id: number): Tag;
+import { Tag, TagInsert } from "../types/db";
+export declare function convertManualBoundingBoxToTag(boundingBox: BoundingBox, event_id: number): TagInsert;
 export declare function convertTagToBoundingBox(tag: Tag, source: EnumSourceBoundingBox): BoundingBox;
 export declare function formatBoundingBoxLabel(label: string): string;

package/dist/helpers/bounding_boxes.js

@@ -1,12 +1,11 @@
 import { SelectionStatus, } from "../types/bounding_boxes";
 export function convertManualBoundingBoxToTag(boundingBox, event_id) {
     const newClassName = boundingBox.label;
-    // try to convert if nan, make it 0
     let newId = Number(boundingBox.id);
     if (isNaN(newId)) {
         newId = 0;
     }
-    const newTag = {
+    return {
         id: newId,
         x: boundingBox.xCenterPercentage,
         y: boundingBox.yCenterPercentage,
@@ -15,11 +14,10 @@ export function convertManualBoundingBoxToTag(boundingBox, event_id) {
         inserted_at: new Date().toISOString(),
         conf: 1,
         observation_type: "manual",
-        class_name: newClassName,
+        class: newClassName,
         event_id: event_id,
         location: null,
     };
-    return newTag;
 }
 export function convertTagToBoundingBox(tag, source) {
     const newBoundingBox = {
@@ -27,7 +25,7 @@ export function convertTagToBoundingBox(tag, source) {
         yCenterPercentage: tag.y,
         widthPercentage: tag.width,
         heightPercentage: tag.height,
-        label: tag.class_name,
+        label: tag.class,
         id: tag.id ? tag.id.toString() : "0",
         left: 0,
         top: 0,

package/dist/helpers/events.d.ts

@@ -1,7 +1,8 @@
 import { IWebResponseCompatible } from "../types/requests";
 import { EnumSessionsVisibility } from "../types/events";
-import { IEvent, EventInsert, EventUpdate } from "../types/db";
+import { IEvent, IEventWithMediaUrl, EventInsert, EventUpdate } from "../types/db";
 import { SupabaseClient } from "@supabase/supabase-js";
+export declare function server_get_event_by_id(id: number, client?: SupabaseClient): Promise<IWebResponseCompatible<IEventWithMediaUrl | null>>;
 export declare function server_get_total_events_by_herd(herd_id: number, sessions_visibility: EnumSessionsVisibility): Promise<IWebResponseCompatible<number>>;
 export declare function server_insert_event(events: EventInsert | EventInsert[], client?: SupabaseClient): Promise<IWebResponseCompatible<IEvent[]>>;
 export declare function server_update_event(events: (EventUpdate & {

package/dist/helpers/events.js

@@ -2,6 +2,30 @@
 import { newServerClient } from "../supabase/server";
 import { EnumWebResponse, IWebResponse, } from "../types/requests";
 import { EnumSessionsVisibility } from "../types/events";
+import { generateSignedUrl } from "./storage";
+export async function server_get_event_by_id(id, client) {
+    const supabase = client || (await newServerClient());
+    const { data, error } = await supabase
+        .from("events")
+        .select("*")
+        .eq("id", id)
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.success(null).to_compatible();
+    }
+    const event = data;
+    let media_url = null;
+    if (event.file_path) {
+        media_url = await generateSignedUrl(event.file_path, undefined, client);
+    }
+    return IWebResponse.success({
+        ...event,
+        media_url,
+    }).to_compatible();
+}
 // function to get total number of events for a herd
 export async function server_get_total_events_by_herd(herd_id, sessions_visibility) {
     const supabase = await newServerClient();

package/dist/helpers/tags.js

@@ -125,7 +125,7 @@ export async function server_update_tags(tags) {
             y: updateData.y,
             width: updateData.width,
             height: updateData.height,
-            class_name: updateData.class_name,
+            class: updateData.class,
             conf: updateData.conf,
             observation_type: updateData.observation_type,
         })
@@ -402,21 +402,40 @@ export async function get_event_and_tags_by_event_id(event_id) {
         timestamp_observation: data[0].timestamp_observation,
         is_public: data[0].is_public,
         herd_id: deviceData.herd_id,
-        tags: (data[0].tags || []).map((tag) => ({
-            id: tag.id,
-            inserted_at: tag.inserted_at,
-            x: tag.x,
-            y: tag.y,
-            width: tag.width,
-            conf: tag.conf,
-            observation_type: tag.observation_type,
-            event_id: tag.event_id,
-            class_name: tag.class_name,
-            height: tag.height,
-            location: tag.location,
-            latitude: tag.location ? extractLatitude(tag.location) : null,
-            longitude: tag.location ? extractLongitude(tag.location) : null,
-        })),
+        tags: (data[0].tags || []).map((tag) => {
+            const loc = tag.location;
+            const lat = loc ? extractLatitude(loc) : null;
+            const lon = loc ? extractLongitude(loc) : null;
+            return {
+                id: tag.id,
+                inserted_at: tag.inserted_at,
+                artifact_id: tag.artifact_id,
+                event_id: tag.event_id,
+                detector: tag.detector,
+                width: tag.width,
+                height: tag.height,
+                conf: tag.conf,
+                x: tag.x,
+                y: tag.y,
+                class: tag.class,
+                timestamp_observation: tag.timestamp_observation,
+                frame_index: tag.frame_index ?? null,
+                origin_location: tag.origin_location ?? null,
+                origin_pitch: tag.origin_pitch,
+                origin_heading: tag.origin_heading,
+                origin_roll: tag.origin_roll,
+                sensor_pitch: tag.sensor_pitch,
+                sensor_yaw: tag.sensor_yaw,
+                sensor_roll: tag.sensor_roll,
+                origin_height: tag.origin_height,
+                subject_location: tag.subject_location ?? null,
+                subject_height: tag.subject_height,
+                origin_latitude: lat,
+                origin_longitude: lon,
+                subject_latitude: null,
+                subject_longitude: null,
+            };
+        }),
         earthranger_url: data[0].earthranger_url,
         file_path: data[0].file_path,
     };

package/dist/hooks/useInfiniteQuery.d.ts

@@ -1,5 +1,5 @@
 import { SupabaseClient } from "@supabase/supabase-js";
-import { IArtifactWithMediaUrl, ISessionWithCoordinates, IEventAndTagsPrettyLocation } from "../types/db";
+import { IArtifactWithMediaUrl, ISessionWithCoordinates, IEventAndTagsPrettyLocation, IFeedItem } from "../types/db";
 interface UseInfiniteScrollOptions {
     limit?: number;
     enabled?: boolean;
@@ -20,5 +20,7 @@ export declare const useInfiniteEventsByHerd: (herdId: number, options: UseInfin
 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 useInfiniteFeedByHerd: (herdId: number, options: UseInfiniteScrollOptions) => InfiniteScrollData<IFeedItem>;
+export declare const useInfiniteFeedByDevice: (deviceId: number, options: UseInfiniteScrollOptions) => InfiniteScrollData<IFeedItem>;
 export declare const useIntersectionObserver: (callback: () => void, options?: IntersectionObserverInit) => import("react").Dispatch<import("react").SetStateAction<Element | null>>;
 export {};

package/dist/hooks/useInfiniteQuery.js

@@ -1,5 +1,5 @@
 import { useState, useCallback, useMemo, useEffect, useRef } from "react";
-import { useGetSessionsInfiniteByHerdQuery, useGetSessionsInfiniteByDeviceQuery, useGetEventsInfiniteByHerdQuery, useGetEventsInfiniteByDeviceQuery, useGetArtifactsInfiniteByHerdQuery, useGetArtifactsInfiniteByDeviceQuery, } from "../store/api";
+import { useGetSessionsInfiniteByHerdQuery, useGetSessionsInfiniteByDeviceQuery, useGetEventsInfiniteByHerdQuery, useGetEventsInfiniteByDeviceQuery, useGetArtifactsInfiniteByHerdQuery, useGetArtifactsInfiniteByDeviceQuery, useGetFeedInfiniteByHerdQuery, useGetFeedInfiniteByDeviceQuery, } from "../store/api";
 // =====================================================
 // SESSIONS INFINITE SCROLL HOOKS
 // =====================================================
@@ -407,6 +407,127 @@ export const useInfiniteArtifactsByDevice = (deviceId, options) => {
         error: currentQuery.error,
     };
 };
+const feedCursorEq = (a, b) => {
+    if (a === null && b === null)
+        return true;
+    if (!a || !b)
+        return false;
+    return a.timestamp === b.timestamp && a.id === b.id && a.feed_type === b.feed_type;
+};
+export const useInfiniteFeedByHerd = (herdId, options) => {
+    const [pages, setPages] = useState([]);
+    const [currentCursor, setCurrentCursor] = useState(null);
+    const prevHerdIdRef = useRef();
+    const currentQuery = useGetFeedInfiniteByHerdQuery({
+        herdId,
+        limit: options.limit || 20,
+        cursor: currentCursor,
+        supabase: options.supabase,
+    }, { skip: !options.enabled || !herdId });
+    useEffect(() => {
+        if (prevHerdIdRef.current !== undefined &&
+            prevHerdIdRef.current !== herdId &&
+            options.enabled &&
+            herdId) {
+            setPages([]);
+            setCurrentCursor(null);
+        }
+        prevHerdIdRef.current = herdId;
+    }, [herdId, options.enabled]);
+    useEffect(() => {
+        if (currentQuery.data && !currentQuery.isLoading) {
+            setPages((prev) => {
+                const existingPage = prev.find((p) => feedCursorEq(p.cursor, currentCursor));
+                if (!existingPage) {
+                    return [
+                        ...prev,
+                        { cursor: currentCursor, data: currentQuery.data.items },
+                    ];
+                }
+                return prev;
+            });
+        }
+    }, [currentQuery.data, currentQuery.isLoading, currentCursor]);
+    const loadMore = useCallback(() => {
+        if (currentQuery.data?.hasMore &&
+            currentQuery.data.nextCursor &&
+            !currentQuery.isLoading) {
+            setCurrentCursor(currentQuery.data.nextCursor);
+        }
+    }, [currentQuery.data, currentQuery.isLoading]);
+    const refetch = useCallback(() => {
+        setPages([]);
+        setCurrentCursor(null);
+        currentQuery.refetch();
+    }, [currentQuery]);
+    const allItems = useMemo(() => pages.flatMap((p) => p.data), [pages]);
+    return {
+        items: allItems,
+        isLoading: currentQuery.isLoading && pages.length === 0,
+        isLoadingMore: currentQuery.isLoading && pages.length > 0,
+        hasMore: currentQuery.data?.hasMore ?? false,
+        loadMore,
+        refetch,
+        error: currentQuery.error,
+    };
+};
+export const useInfiniteFeedByDevice = (deviceId, options) => {
+    const [pages, setPages] = useState([]);
+    const [currentCursor, setCurrentCursor] = useState(null);
+    const prevDeviceIdRef = useRef();
+    const currentQuery = useGetFeedInfiniteByDeviceQuery({
+        deviceId,
+        limit: options.limit || 20,
+        cursor: currentCursor,
+        supabase: options.supabase,
+    }, { skip: !options.enabled || !deviceId });
+    useEffect(() => {
+        if (prevDeviceIdRef.current !== undefined &&
+            prevDeviceIdRef.current !== deviceId &&
+            options.enabled &&
+            deviceId) {
+            setPages([]);
+            setCurrentCursor(null);
+        }
+        prevDeviceIdRef.current = deviceId;
+    }, [deviceId, options.enabled]);
+    useEffect(() => {
+        if (currentQuery.data && !currentQuery.isLoading) {
+            setPages((prev) => {
+                const existingPage = prev.find((p) => feedCursorEq(p.cursor, currentCursor));
+                if (!existingPage) {
+                    return [
+                        ...prev,
+                        { cursor: currentCursor, data: currentQuery.data.items },
+                    ];
+                }
+                return prev;
+            });
+        }
+    }, [currentQuery.data, currentQuery.isLoading, currentCursor]);
+    const loadMore = useCallback(() => {
+        if (currentQuery.data?.hasMore &&
+            currentQuery.data.nextCursor &&
+            !currentQuery.isLoading) {
+            setCurrentCursor(currentQuery.data.nextCursor);
+        }
+    }, [currentQuery.data, currentQuery.isLoading]);
+    const refetch = useCallback(() => {
+        setPages([]);
+        setCurrentCursor(null);
+        currentQuery.refetch();
+    }, [currentQuery]);
+    const allItems = useMemo(() => pages.flatMap((p) => p.data), [pages]);
+    return {
+        items: allItems,
+        isLoading: currentQuery.isLoading && pages.length === 0,
+        isLoadingMore: currentQuery.isLoading && pages.length > 0,
+        hasMore: currentQuery.data?.hasMore ?? false,
+        loadMore,
+        refetch,
+        error: currentQuery.error,
+    };
+};
 // =====================================================
 // INTERSECTION OBSERVER HOOK FOR AUTO-LOADING
 // =====================================================