@adventurelabs/scout-core 2.0.18 → 2.1.0

package/dist/helpers/mediaState.js

@@ -0,0 +1,86 @@
+import { isNonEmptyStorageFilePath } from "./storagePath";
+/** Extensions classified by the client; image/video lists mirror the queue predicates. */
+export const VIDEO_FILE_EXTENSIONS = [
+    "mp4",
+    "m4v",
+    "webm",
+    "mov",
+    "mkv",
+    "avi",
+];
+export const IMAGE_FILE_EXTENSIONS = [
+    "jpg",
+    "jpeg",
+    "png",
+    "gif",
+    "webp",
+    "bmp",
+];
+export const AUDIO_FILE_EXTENSIONS = [
+    "wav",
+    "mp3",
+    "m4a",
+    "aac",
+    "flac",
+    "ogg",
+];
+const KIND_BY_EXTENSION = new Map([
+    ...VIDEO_FILE_EXTENSIONS.map((ext) => [ext, "video"]),
+    ...IMAGE_FILE_EXTENSIONS.map((ext) => [ext, "image"]),
+    ...AUDIO_FILE_EXTENSIONS.map((ext) => [ext, "audio"]),
+]);
+/** Lowercased extension of a storage path or URL, or null when there is none. */
+export function mediaFileExtension(filePath) {
+    if (!isNonEmptyStorageFilePath(filePath))
+        return null;
+    const withoutQuery = filePath.split(/[?#]/)[0];
+    const name = withoutQuery.slice(withoutQuery.lastIndexOf("/") + 1);
+    const dot = name.lastIndexOf(".");
+    if (dot <= 0 || dot === name.length - 1)
+        return null;
+    return name.slice(dot + 1).toLowerCase();
+}
+/** One classifier for events and artifacts; a recognized extension wins over the stored type. */
+export function classifyMedia(row) {
+    const extension = mediaFileExtension(row.file_path) ?? mediaFileExtension(row.media_url);
+    const byExtension = extension ? KIND_BY_EXTENSION.get(extension) : undefined;
+    if (byExtension)
+        return byExtension;
+    if (row.media_type)
+        return row.media_type;
+    if (row.modality === "video")
+        return "video";
+    return "unknown";
+}
+export const isVideoMedia = (row) => classifyMedia(row) === "video";
+/** Readiness of image/video derivatives or the original for media without derivatives. */
+export function mediaStatus(row) {
+    const kind = classifyMedia(row);
+    if (kind !== "image" && kind !== "video")
+        return originalMediaStatus(row);
+    const derivatives = kind === "video"
+        ? [
+            { path: row.proxy_file_path, url: row.proxy_url },
+            { path: row.thumbnail_file_path, url: row.thumbnail_url },
+        ]
+        : [{ path: row.thumbnail_file_path, url: row.thumbnail_url }];
+    const present = derivatives.filter(({ path }) => isNonEmptyStorageFilePath(path));
+    if (present.some(({ url }) => url))
+        return "ready";
+    // An unsigned derivative is recoverable by re-signing, unlike work that never ran.
+    if (present.length > 0)
+        return "url_unavailable";
+    if (row.processing_blocked_at)
+        return "blocked";
+    return "processing";
+}
+/** Readiness of the original media itself, ignoring derivatives. */
+export function originalMediaStatus(row) {
+    if (row.media_url)
+        return "ready";
+    if (isNonEmptyStorageFilePath(row.file_path))
+        return "url_unavailable";
+    if (row.processing_blocked_at)
+        return "blocked";
+    return "processing";
+}

package/dist/helpers/media_urls.d.ts

@@ -1,7 +1,8 @@
 import type { SupabaseClient } from "@supabase/supabase-js";
-import type { IArtifact, IArtifactWithMediaUrl, ISignedMediaUrls } from "../types/db";
+import type { IArtifact, IArtifactWithMediaUrl, IGalleryItem, IGalleryItemRow, ISignedMediaUrls } from "../types/db";
 import type { Database } from "../types/supabase";
 import { type IEventMediaPaths } from "./eventMedia";
 export declare function createSignedUrlMap(client: SupabaseClient<Database>, paths: Iterable<string | null | undefined>): Promise<Map<string, string | null>>;
 export declare function addEventMediaUrls<T extends IEventMediaPaths>(client: SupabaseClient<Database>, events: T[]): Promise<Array<T & ISignedMediaUrls>>;
 export declare function addArtifactMediaUrls(client: SupabaseClient<Database>, artifacts: IArtifact[]): Promise<IArtifactWithMediaUrl[]>;
+export declare function addGalleryMediaUrls(client: SupabaseClient<Database>, items: IGalleryItemRow[]): Promise<IGalleryItem[]>;

package/dist/helpers/media_urls.js

@@ -1,5 +1,6 @@
 import { collectArtifactStoragePaths, withArtifactMediaUrls, } from "./artifactMedia";
-import { collectEventStoragePaths, withEventMediaUrls, } from "./eventMedia";
+import { withGalleryMediaUrls } from "./galleryMedia";
+import { collectMediaStoragePaths, withEventMediaUrls, } from "./eventMedia";
 import { generateSignedUrlsBatchWithClient } from "./storage_internal";
 import { isNonEmptyStorageFilePath } from "./storagePath";
 export async function createSignedUrlMap(client, paths) {
@@ -8,10 +9,20 @@ export async function createSignedUrlMap(client, paths) {
     return new Map(uniquePaths.map((path, index) => [path, urls[index]]));
 }
 export async function addEventMediaUrls(client, events) {
-    const urlMap = await createSignedUrlMap(client, collectEventStoragePaths(events));
+    const urlMap = await createSignedUrlMap(client, collectMediaStoragePaths(events));
     return events.map((event) => withEventMediaUrls(event, urlMap));
 }
 export async function addArtifactMediaUrls(client, artifacts) {
     const urlMap = await createSignedUrlMap(client, collectArtifactStoragePaths(artifacts));
     return artifacts.map((artifact) => withArtifactMediaUrls(artifact, urlMap));
 }
+export async function addGalleryMediaUrls(client, items) {
+    let urlMap = new Map();
+    try {
+        urlMap = await createSignedUrlMap(client, collectMediaStoragePaths(items));
+    }
+    catch (error) {
+        console.warn("Failed to generate signed URLs for gallery:", error);
+    }
+    return items.map((item) => withGalleryMediaUrls(item, urlMap));
+}

package/dist/helpers/parts.d.ts

@@ -1,8 +1,13 @@
 import { Database } from "../types/supabase";
-import { EntityLifecycle, IPart, IPartWithProduct, PartInsert } from "../types/db";
+import { EntityLifecycle, IPart, IProductCatalog, PartInsert } from "../types/db";
 import { IWebResponseCompatible } from "../types/requests";
 import { SupabaseClient } from "@supabase/supabase-js";
 import { LifecycleUpdateOptions } from "./lifecycle";
+/** Parts grouped by device, plus one shared copy of each referenced product. */
+export interface IPartsByDeviceWithCatalog {
+    parts_by_device: Record<number, IPart[]>;
+    product_catalog: IProductCatalog;
+}
 export declare function get_parts_by_device_id(client: SupabaseClient<Database>, device_id: number): Promise<IWebResponseCompatible<IPart[]>>;
 export declare function get_part_by_id(client: SupabaseClient<Database>, part_id: number): Promise<IWebResponseCompatible<IPart | null>>;
 export declare function get_parts_by_serial_number(client: SupabaseClient<Database>, serial_number: string): Promise<IWebResponseCompatible<IPart[]>>;
@@ -16,7 +21,7 @@ export declare function delete_part(client: SupabaseClient<Database>, part_id: n
 export declare function update_part_status(client: SupabaseClient<Database>, part_id: number, lifecycle: EntityLifecycle, options?: LifecycleUpdateOptions): Promise<IWebResponseCompatible<IPart | null>>;
 export declare function get_parts_by_certificate_id(client: SupabaseClient<Database>, certificate_id: number): Promise<IWebResponseCompatible<IPart[]>>;
 export declare function get_parts_by_herd_id(client: SupabaseClient<Database>, herd_id: number): Promise<IWebResponseCompatible<IPart[]>>;
-export declare function get_parts_by_herd_ids(client: SupabaseClient<Database>, herd_ids: number[]): Promise<IWebResponseCompatible<Record<number, IPartWithProduct[]>>>;
+export declare function get_parts_by_herd_ids(client: SupabaseClient<Database>, herd_ids: number[]): Promise<IWebResponseCompatible<IPartsByDeviceWithCatalog>>;
 export declare function restore_part(client: SupabaseClient<Database>, part_id: number, options?: LifecycleUpdateOptions): Promise<IWebResponseCompatible<IPart | null>>;
 export declare function hard_delete_part(client: SupabaseClient<Database>, part_id: number): Promise<IWebResponseCompatible<IPart | null>>;
 export declare function get_deleted_parts_by_device_id(client: SupabaseClient<Database>, device_id: number): Promise<IWebResponseCompatible<IPart[]>>;

package/dist/helpers/parts.js

@@ -1,5 +1,6 @@
 import { IWebResponse } from "../types/requests";
 import { update_part_lifecycle } from "./lifecycle";
+import { build_product_catalog, EMPTY_PRODUCT_CATALOG, } from "./product_catalog";
 export async function get_parts_by_device_id(client, device_id) {
     const { data, error } = await client
         .from("parts")
@@ -173,7 +174,10 @@ export async function get_parts_by_herd_id(client, herd_id) {
 export async function get_parts_by_herd_ids(client, herd_ids) {
     var _a;
     if (herd_ids.length === 0) {
-        return IWebResponse.success({}).to_compatible();
+        return IWebResponse.success({
+            parts_by_device: {},
+            product_catalog: EMPTY_PRODUCT_CATALOG,
+        }).to_compatible();
     }
     const { data, error } = await client
         .from("parts")
@@ -191,18 +195,23 @@ export async function get_parts_by_herd_ids(client, herd_ids) {
     if (error) {
         return IWebResponse.error(error.message).to_compatible();
     }
-    const grouped = {};
+    const parts_by_device = {};
+    const product_entries = [];
     for (const row of data ?? []) {
         if (row.device_id == null)
             continue;
         const { product_numbers, devices: _devices, ...partRow } = row;
-        const part = {
-            ...partRow,
+        const part = partRow;
+        product_entries.push({
+            product_number: part.product_number,
             product: product_numbers?.products ?? null,
-        };
-        (grouped[_a = row.device_id] ?? (grouped[_a] = [])).push(part);
+        });
+        (parts_by_device[_a = row.device_id] ?? (parts_by_device[_a] = [])).push(part);
     }
-    return IWebResponse.success(grouped).to_compatible();
+    return IWebResponse.success({
+        parts_by_device,
+        product_catalog: build_product_catalog(product_entries),
+    }).to_compatible();
 }
 export async function restore_part(client, part_id, options) {
     const { data, error } = await client

package/dist/helpers/parts_server.d.ts

@@ -193,7 +193,7 @@ export declare function server_get_parts_by_herd_id(herd_id: number): Promise<im
     serial_number: string;
     updated_at: string | null;
 }[]>>;
-export declare function server_get_parts_by_herd_ids(herd_ids: number[]): Promise<import("../types").IWebResponseCompatible<Record<number, import("../types").IPartWithProduct[]>>>;
+export declare function server_get_parts_by_herd_ids(herd_ids: number[]): Promise<import("../types").IWebResponseCompatible<import("./parts").IPartsByDeviceWithCatalog>>;
 export declare function server_restore_part(part_id: number, options?: LifecycleUpdateOptions): Promise<import("../types").IWebResponseCompatible<{
     certificate_id: number | null;
     created_at: string;

package/dist/helpers/product_catalog.d.ts

@@ -0,0 +1,9 @@
+import { IDevice, IPart, IProduct, IProductCatalog } from "../types/db";
+export declare const EMPTY_PRODUCT_CATALOG: IProductCatalog;
+export declare function build_product_catalog(entries: Iterable<{
+    product_number: string;
+    product: IProduct | null | undefined;
+}>): IProductCatalog;
+export declare function get_product_for_part(catalog: IProductCatalog | null | undefined, part: Pick<IPart, "product_number"> | null | undefined): IProduct | null;
+/** Distinct products across a device's parts, in part order. */
+export declare function get_products_for_device(catalog: IProductCatalog | null | undefined, device: Pick<IDevice, "parts"> | null | undefined): IProduct[];

package/dist/helpers/product_catalog.js

@@ -0,0 +1,36 @@
+export const EMPTY_PRODUCT_CATALOG = {
+    products: {},
+    product_id_by_number: {},
+};
+export function build_product_catalog(entries) {
+    var _a, _b;
+    const catalog = {
+        products: {},
+        product_id_by_number: {},
+    };
+    for (const { product_number, product } of entries) {
+        if (!product)
+            continue;
+        catalog.product_id_by_number[product_number] = product.id;
+        (_a = catalog.products)[_b = product.id] ?? (_a[_b] = product);
+    }
+    return catalog;
+}
+export function get_product_for_part(catalog, part) {
+    if (!catalog || !part?.product_number)
+        return null;
+    const product_id = catalog.product_id_by_number[part.product_number];
+    if (product_id == null)
+        return null;
+    return catalog.products[product_id] ?? null;
+}
+/** Distinct products across a device's parts, in part order. */
+export function get_products_for_device(catalog, device) {
+    const products = new Map();
+    for (const part of device?.parts ?? []) {
+        const product = get_product_for_part(catalog, part);
+        if (product)
+            products.set(product.id, product);
+    }
+    return Array.from(products.values());
+}

package/dist/helpers/session_incidents_server.d.ts

@@ -17,6 +17,7 @@ export declare function server_get_session_incidents_by_session_id(session_id: n
     operator: string | null;
     photo: string | null;
     session_id: number;
+    timestamp_observation: string | null;
     updated_at: string;
     updated_by: string | null;
 }[]>>;
@@ -38,6 +39,7 @@ export declare function server_get_session_incident_by_id(incident_id: number):
     operator: string | null;
     photo: string | null;
     session_id: number;
+    timestamp_observation: string | null;
     updated_at: string;
     updated_by: string | null;
 } | null>>;
@@ -59,6 +61,7 @@ export declare function server_create_session_incident(row: SessionIncidentInser
     operator: string | null;
     photo: string | null;
     session_id: number;
+    timestamp_observation: string | null;
     updated_at: string;
     updated_by: string | null;
 } | null>>;
@@ -80,6 +83,7 @@ export declare function server_update_session_incident(incident_id: number, patc
     operator: string | null;
     photo: string | null;
     session_id: number;
+    timestamp_observation: string | null;
     updated_at: string;
     updated_by: string | null;
 } | null>>;
@@ -101,6 +105,7 @@ export declare function server_delete_session_incident(incident_id: number): Pro
     operator: string | null;
     photo: string | null;
     session_id: number;
+    timestamp_observation: string | null;
     updated_at: string;
     updated_by: string | null;
 } | null>>;

package/dist/helpers/storage_internal.d.ts

@@ -1,4 +1,5 @@
-import { SupabaseClient } from "@supabase/supabase-js";
-import { Database } from "../types/supabase";
-export declare function generateSignedUrlsBatchWithClient(supabase: SupabaseClient<Database>, filePaths: string[], expiresIn?: number): Promise<(string | null)[]>;
+import type { SupabaseClient } from "@supabase/supabase-js";
+import type { Database } from "../types/supabase";
+/** Signs every path with one request per bucket rather than one per path. */
+export declare function generateSignedUrlsBatchWithClient(supabase: SupabaseClient<Database>, filePaths: readonly string[], expiresIn?: number): Promise<(string | null)[]>;
 export declare function generateSignedUrlWithClient(supabase: SupabaseClient<Database>, filePath: string, expiresIn?: number): Promise<string | null>;

package/dist/helpers/storage_internal.js

@@ -1,27 +1,59 @@
 import { SIGNED_URL_EXPIRATION_SECONDS } from "../constants/db";
 import { parseStorageFilePath } from "./storagePath";
+const normalizeExpiration = (expiresIn) => Number.isSafeInteger(expiresIn) && expiresIn > 0
+    ? expiresIn
+    : SIGNED_URL_EXPIRATION_SECONDS;
+/** Signs every path with one request per bucket rather than one per path. */
 export async function generateSignedUrlsBatchWithClient(supabase, filePaths, expiresIn = SIGNED_URL_EXPIRATION_SECONDS) {
-    return Promise.all(filePaths.map(async (filePath) => {
+    const signedUrls = filePaths.map(() => null);
+    const expirationSeconds = normalizeExpiration(expiresIn);
+    const requestsByBucket = new Map();
+    let unparsedPathCount = 0;
+    filePaths.forEach((filePath, index) => {
+        const parsed = parseStorageFilePath(filePath);
+        if (!parsed) {
+            unparsedPathCount += 1;
+            return;
+        }
+        const requests = requestsByBucket.get(parsed.bucket) ?? new Map();
+        const indices = requests.get(parsed.objectPath);
+        if (indices) {
+            indices.push(index);
+        }
+        else {
+            requests.set(parsed.objectPath, [index]);
+        }
+        requestsByBucket.set(parsed.bucket, requests);
+    });
+    // Legacy device-id-prefixed paths never parse, so warn once per page instead of per path.
+    if (unparsedPathCount > 0) {
+        console.warn(`Skipped ${unparsedPathCount} unparseable storage path(s)`);
+    }
+    await Promise.all(Array.from(requestsByBucket, async ([bucket, requestsByPath]) => {
+        const objectPaths = Array.from(requestsByPath.keys());
         try {
-            const parsed = parseStorageFilePath(filePath);
-            if (!parsed) {
-                console.error("Invalid file path:", filePath);
-                return null;
-            }
             const { data, error } = await supabase.storage
-                .from(parsed.bucket)
-                .createSignedUrl(parsed.objectPath, expiresIn);
-            if (error) {
-                console.warn(`Error generating signed URL for ${filePath}:`, error.message);
-                return null;
+                .from(bucket)
+                .createSignedUrls(objectPaths, expirationSeconds);
+            if (error || !data) {
+                console.warn(`Error generating signed URLs for bucket ${bucket}:`, error?.message);
+                return;
             }
-            return data.signedUrl;
+            // Signing fails per path, so an unsigned path stays null without losing the others.
+            data.forEach((entry, position) => {
+                const objectPath = entry.path != null && requestsByPath.has(entry.path)
+                    ? entry.path
+                    : objectPaths[position];
+                requestsByPath.get(objectPath)?.forEach((index) => {
+                    signedUrls[index] = entry.signedUrl || null;
+                });
+            });
         }
         catch (error) {
-            console.warn(`Exception generating signed URL for ${filePath}:`, error);
-            return null;
+            console.warn(`Exception generating signed URLs for bucket ${bucket}:`, error);
         }
     }));
+    return signedUrls;
 }
 export async function generateSignedUrlWithClient(supabase, filePath, expiresIn = SIGNED_URL_EXPIRATION_SECONDS) {
     const [signedUrl] = await generateSignedUrlsBatchWithClient(supabase, [filePath], expiresIn);

package/dist/helpers/tags.queries.js

@@ -344,6 +344,8 @@ export async function get_event_and_tags_by_event_id_query(client, event_id) {
         thumbnail_generated_at: data[0].thumbnail_generated_at ?? null,
         proxy_file_path: data[0].proxy_file_path ?? null,
         proxy_generated_at: data[0].proxy_generated_at ?? null,
+        processing_blocked_at: data[0].processing_blocked_at ?? null,
+        processing_blocked_reason: data[0].processing_blocked_reason ?? null,
     };
     const [eventWithUrl] = await addEventMediaUrls(client, [transformedData]);
     return IWebResponse.success(eventWithUrl).to_compatible();

package/dist/hooks/index.d.ts

@@ -18,5 +18,5 @@ export { useScoutRealtimeMaintenanceRequests } from "./useScoutRealtimeMaintenan
 export { useScoutRealtimeContacts } from "./useScoutRealtimeContacts";
 export { useScoutRealtimeSessionIncidents } from "./useScoutRealtimeSessionIncidents";
 export { useScoutRealtimeOperatingContexts, type ComplianceRealtimeData, type ComplianceRealtimeRow, type OperatingContextRealtimeData, type OperatingContextRealtimeRow, } from "./useScoutRealtimeOperatingContexts";
-export { useInfiniteSessionsByHerd, useInfiniteSessionsByDevice, useInfiniteEventsByHerd, useInfiniteEventsByDevice, useInfiniteArtifactsByHerd, useInfiniteArtifactsByDevice, useInfiniteFeedByHerd, useInfiniteFeedByDevice, useInfiniteAnalysisJobs, useInfiniteAnalysisTasks, useIntersectionObserver, type InfiniteScrollData, type InfiniteRefetchOptions, type UseInfiniteScrollOptions, type UseAnalysisJobsInfiniteOptions, type UseAnalysisTasksInfiniteOptions, } from "./useInfiniteQuery";
+export { useInfiniteSessionsByHerd, useInfiniteSessionsByDevice, useInfiniteEventsByHerd, useInfiniteEventsByDevice, useInfiniteArtifactsByHerd, useInfiniteArtifactsByDevice, useInfiniteFeedByHerd, useInfiniteFeedByDevice, useInfiniteGalleryByHerd, useInfiniteGalleryByDevice, useInfiniteAnalysisJobs, useInfiniteAnalysisTasks, useIntersectionObserver, type InfiniteScrollData, type InfiniteRefetchOptions, type UseInfiniteScrollOptions, type UseAnalysisJobsInfiniteOptions, type UseAnalysisTasksInfiniteOptions, } from "./useInfiniteQuery";
 export { useLoadingPerformance, useSessionSummariesByHerd, useHasSessionSummaries, } from "../store/hooks";

package/dist/hooks/index.js

@@ -19,6 +19,6 @@ export { useScoutRealtimeContacts } from "./useScoutRealtimeContacts";
 export { useScoutRealtimeSessionIncidents } from "./useScoutRealtimeSessionIncidents";
 export { useScoutRealtimeOperatingContexts, } from "./useScoutRealtimeOperatingContexts";
 // RTK Query infinite scroll hooks
-export { useInfiniteSessionsByHerd, useInfiniteSessionsByDevice, useInfiniteEventsByHerd, useInfiniteEventsByDevice, useInfiniteArtifactsByHerd, useInfiniteArtifactsByDevice, useInfiniteFeedByHerd, useInfiniteFeedByDevice, useInfiniteAnalysisJobs, useInfiniteAnalysisTasks, useIntersectionObserver, } from "./useInfiniteQuery";
+export { useInfiniteSessionsByHerd, useInfiniteSessionsByDevice, useInfiniteEventsByHerd, useInfiniteEventsByDevice, useInfiniteArtifactsByHerd, useInfiniteArtifactsByDevice, useInfiniteFeedByHerd, useInfiniteFeedByDevice, useInfiniteGalleryByHerd, useInfiniteGalleryByDevice, useInfiniteAnalysisJobs, useInfiniteAnalysisTasks, useIntersectionObserver, } from "./useInfiniteQuery";
 // Session summaries and performance hooks
 export { useLoadingPerformance, useSessionSummariesByHerd, useHasSessionSummaries, } from "../store/hooks";

package/dist/hooks/useInfiniteQuery.d.ts

@@ -1,5 +1,5 @@
 import { SupabaseClient } from "@supabase/supabase-js";
-import { IArtifactWithMediaUrl, ISessionWithCoordinates, IEventAndTagsPrettyLocation, IFeedItem, IAnalysisJob, IAnalysisTask, AnalysisWorkStatus } from "../types/db";
+import { IArtifactWithMediaUrl, ISessionWithCoordinates, IEventAndTagsPrettyLocation, IFeedItem, IGalleryItem, IAnalysisJob, IAnalysisTask, AnalysisWorkStatus } from "../types/db";
 export interface UseInfiniteScrollOptions {
     limit?: number;
     enabled?: boolean;
@@ -37,6 +37,8 @@ export declare const useInfiniteArtifactsByHerd: (herdId: number, options: UseIn
 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 useInfiniteGalleryByHerd: (herdId: number, options: UseInfiniteScrollOptions) => InfiniteScrollData<IGalleryItem>;
+export declare const useInfiniteGalleryByDevice: (deviceId: number, options: UseInfiniteScrollOptions) => InfiniteScrollData<IGalleryItem>;
 export interface UseAnalysisJobsInfiniteOptions {
     limit?: number;
     enabled?: boolean;

package/dist/hooks/useInfiniteQuery.js

@@ -1,34 +1,8 @@
 "use client";
 import { useState, useCallback, useMemo, useEffect, useRef } from "react";
-import { useGetSessionsInfiniteByHerdQuery, useGetSessionsInfiniteByDeviceQuery, useGetEventsInfiniteByHerdQuery, useGetEventsInfiniteByDeviceQuery, useGetArtifactsInfiniteByHerdQuery, useGetArtifactsInfiniteByDeviceQuery, useGetFeedInfiniteByHerdQuery, useGetFeedInfiniteByDeviceQuery, useGetAnalysisJobsInfiniteQuery, useGetAnalysisTasksInfiniteQuery, } from "../store/api";
-/** Signed media URLs are re-minted on every fetch, so they never indicate a changed row. */
-const REMINTED_URL_KEYS = new Set(["media_url", "thumbnail_url", "proxy_url"]);
-function rowsEqual(left, right) {
-    if (left === right)
-        return true;
-    if (typeof left !== "object" ||
-        typeof right !== "object" ||
-        left === null ||
-        right === null) {
-        return false;
-    }
-    if (Array.isArray(left) || Array.isArray(right)) {
-        return (Array.isArray(left) &&
-            Array.isArray(right) &&
-            left.length === right.length &&
-            left.every((item, index) => rowsEqual(item, right[index])));
-    }
-    const keys = Object.keys(left).filter((key) => !REMINTED_URL_KEYS.has(key));
-    const rightKeys = Object.keys(right).filter((key) => !REMINTED_URL_KEYS.has(key));
-    return (keys.length === rightKeys.length &&
-        keys.every((key) => Object.prototype.hasOwnProperty.call(right, key) &&
-            rowsEqual(Reflect.get(left, key), Reflect.get(right, key))));
-}
-/**
- * Reuse the previous row object when a refetch returned the same content, so consumers
- * can memoize on row identity. Rows that only differ by a re-minted signed URL keep the
- * earlier object, and therefore the earlier URL, until the row itself changes.
- */
+import { useGetSessionsInfiniteByHerdQuery, useGetSessionsInfiniteByDeviceQuery, useGetEventsInfiniteByHerdQuery, useGetEventsInfiniteByDeviceQuery, useGetArtifactsInfiniteByHerdQuery, useGetArtifactsInfiniteByDeviceQuery, useGetFeedInfiniteByHerdQuery, useGetFeedInfiniteByDeviceQuery, useGetGalleryInfiniteByHerdQuery, useGetGalleryInfiniteByDeviceQuery, useGetAnalysisJobsInfiniteQuery, useGetAnalysisTasksInfiniteQuery, } from "../store/api";
+import { normalizePageLimit, rowsEqualIgnoringSignedUrls, withRefreshedSignedUrls, } from "../helpers/mediaRows";
+/** Reuses the previous row object, with fresh signed URLs, so consumers can memoize on identity. */
 function preserveRowReferences(previous, next, rowKey) {
     const previousByKey = new Map(previous
         .map((row) => [rowKey(row), row])
@@ -36,7 +10,9 @@ function preserveRowReferences(previous, next, rowKey) {
     return next.map((row) => {
         const key = rowKey(row);
         const previousRow = key == null ? undefined : previousByKey.get(key);
-        return previousRow && rowsEqual(previousRow, row) ? previousRow : row;
+        return previousRow && rowsEqualIgnoringSignedUrls(previousRow, row)
+            ? withRefreshedSignedUrls(previousRow, row)
+            : row;
     });
 }
 /** Cursors are flat records of scalars, so a shallow comparison identifies a page. */
@@ -51,6 +27,7 @@ function sameCursor(left, right) {
 }
 const rowId = (row) => row.id;
 const feedRowKey = (row) => `${row.sort_ts ?? ""}_${row.sort_id ?? ""}_${row.feed_type ?? ""}`;
+const galleryRowKey = (row) => `${row.feed_type ?? ""}_${row.id ?? ""}`;
 const emptyPaging = (key) => ({
     key,
     cursor: null,
@@ -234,7 +211,7 @@ function useFiltersKey(options) {
     ]);
 }
 const rangeArgs = (options) => ({
-    limit: options.limit || 20,
+    limit: normalizePageLimit(options.limit),
     supabase: options.supabase,
     rangeStart: options.rangeStart ?? null,
     rangeEnd: options.rangeEnd ?? null,
@@ -259,16 +236,12 @@ const artifactsPage = (response) => ({
     nextCursor: response.nextCursor,
     hasMore: response.hasMore,
 });
-const feedPage = (response) => {
-    const rows = Array.isArray(response.items) ? response.items : [];
-    return {
-        rows,
-        nextCursor: response.nextCursor,
-        // The feed RPC can return fewer rows than the limit while more still exist, so any
-        // non-empty page with a next cursor means there is more to load.
-        hasMore: rows.length > 0 && response.nextCursor !== null,
-    };
-};
+/** The RPCs over-fetch by one to answer `hasMore`, so an exactly-full page is terminal. */
+const itemsPage = (response) => ({
+    rows: Array.isArray(response.items) ? response.items : [],
+    nextCursor: response.nextCursor,
+    hasMore: response.hasMore,
+});
 const analysisJobsPage = (response) => ({
     rows: response.jobs,
     nextCursor: response.nextCursor,
@@ -350,7 +323,7 @@ export const useInfiniteFeedByHerd = (herdId, options) => {
     const paging = usePaging(`herd:${herdId}|${filtersKey}`);
     const query = useGetFeedInfiniteByHerdQuery({ herdId, cursor: paging.cursor, ...rangeArgs(options) }, { skip: !options.enabled || !herdId });
     return useInfinitePages(paging, query, {
-        toPage: feedPage,
+        toPage: itemsPage,
         rowKey: feedRowKey,
     });
 };
@@ -359,10 +332,31 @@ export const useInfiniteFeedByDevice = (deviceId, options) => {
     const paging = usePaging(`device:${deviceId}|${filtersKey}`);
     const query = useGetFeedInfiniteByDeviceQuery({ deviceId, cursor: paging.cursor, ...rangeArgs(options) }, { skip: !options.enabled || !deviceId });
     return useInfinitePages(paging, query, {
-        toPage: feedPage,
+        toPage: itemsPage,
         rowKey: feedRowKey,
     });
 };
+// =====================================================
+// GALLERY (lean merged events + artifacts)
+// =====================================================
+export const useInfiniteGalleryByHerd = (herdId, options) => {
+    const filtersKey = useFiltersKey(options);
+    const paging = usePaging(`herd:${herdId}|${filtersKey}`);
+    const query = useGetGalleryInfiniteByHerdQuery({ herdId, cursor: paging.cursor, ...rangeArgs(options) }, { skip: !options.enabled || !herdId });
+    return useInfinitePages(paging, query, {
+        toPage: itemsPage,
+        rowKey: galleryRowKey,
+    });
+};
+export const useInfiniteGalleryByDevice = (deviceId, options) => {
+    const filtersKey = useFiltersKey(options);
+    const paging = usePaging(`device:${deviceId}|${filtersKey}`);
+    const query = useGetGalleryInfiniteByDeviceQuery({ deviceId, cursor: paging.cursor, ...rangeArgs(options) }, { skip: !options.enabled || !deviceId });
+    return useInfinitePages(paging, query, {
+        toPage: itemsPage,
+        rowKey: galleryRowKey,
+    });
+};
 export const useInfiniteAnalysisJobs = (options) => {
     const status = options.status ?? null;
     const paging = usePaging(`status:${status}`);

package/dist/hooks/useScoutRealtimeBroadcast.d.ts

@@ -8,5 +8,9 @@ export type ScoutRealtimeBroadcastOptions = {
     backoffInitialMs?: number;
     backoffMaxMs?: number;
     backoffMaxAttempts?: number;
+    /** Called once a topic is back after a drop, since broadcasts sent meanwhile are gone. */
+    onMissedUpdates?: () => void;
+    /** Rejoin topics no longer joined when the tab regains focus or the browser reconnects. */
+    recoverOnFocus?: boolean;
 };
 export declare function useScoutRealtimeBroadcast<T>(scoutSupabase: SupabaseClient<Database>, topics: string[], options?: ScoutRealtimeBroadcastOptions, rowFilter?: (row: T) => boolean): [RealtimeData<T> | null, () => void];