@adventurelabs/scout-core 1.4.31 → 1.4.32

package/dist/hooks/useInfiniteQuery.d.ts

@@ -20,6 +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>;
+/** useInfiniteFeedByHerd: logic matches useInfiniteFeedByHerdDummy verbatim; only the fetch is via API (RTK Query) instead of supabase.rpc. */
 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>>;

package/dist/hooks/useInfiniteQuery.js

@@ -408,96 +408,131 @@ export const useInfiniteArtifactsByDevice = (deviceId, options) => {
     };
 };
 const feedCursorEq = (a, b) => {
-    if (a === null && b === null)
+    if (a === b)
         return true;
-    if (!a || !b)
+    if (a == null || b == null)
         return false;
-    return a.timestamp === b.timestamp && a.id === b.id && a.feed_type === b.feed_type;
+    return (a.timestamp === b.timestamp &&
+        a.id === b.id &&
+        a.feed_type === b.feed_type);
 };
+/** useInfiniteFeedByHerd: logic matches useInfiniteFeedByHerdDummy verbatim; only the fetch is via API (RTK Query) instead of supabase.rpc. */
 export const useInfiniteFeedByHerd = (herdId, options) => {
+    const limit = options.limit ?? 20;
+    const enabled = !!(options.enabled && herdId);
     const [pages, setPages] = useState([]);
     const [currentCursor, setCurrentCursor] = useState(null);
-    // Match dummy: use state so hasMore/nextCursor trigger re-renders and loadMore sees latest (ref was not updating UI)
-    const [lastResult, setLastResult] = useState(null);
+    const [currentResult, setCurrentResult] = useState(null);
     const prevHerdIdRef = useRef(undefined);
     const lastAddedCursorRef = useRef(undefined);
     const pagesLengthRef = useRef(0);
     const currentQuery = useGetFeedInfiniteByHerdQuery({
         herdId,
-        limit: options.limit || 20,
+        limit,
         cursor: currentCursor,
         supabase: options.supabase,
-    }, { skip: !options.enabled || !herdId });
+    }, { skip: !enabled });
+    const isLoading = currentQuery.isLoading;
     useEffect(() => {
         pagesLengthRef.current = pages.length;
     }, [pages.length]);
-    // Clear all state whenever herd id changes (including to/from undefined)
+    // Reset when herd changes (match dummy: prev !== herdId && enabled && herdId)
     useEffect(() => {
         if (prevHerdIdRef.current !== undefined &&
-            prevHerdIdRef.current !== herdId) {
+            prevHerdIdRef.current !== herdId &&
+            enabled &&
+            herdId) {
             setPages([]);
             setCurrentCursor(null);
+            setCurrentResult(null);
             lastAddedCursorRef.current = undefined;
-            setLastResult(null);
         }
         prevHerdIdRef.current = herdId;
-    }, [herdId]);
-    // When we request a new page (cursor changed), clear ref so we merge the new response
+    }, [herdId, enabled]);
+    // When cursor changes, clear ref so we merge the new response
     useEffect(() => {
         lastAddedCursorRef.current = undefined;
     }, [currentCursor]);
+    // Merge when we have data (mirror dummy's .then() logic; fetch is done by RTK Query)
     useEffect(() => {
         if (!currentQuery.data || currentQuery.isLoading)
             return;
-        // Match dummy: only skip merge when we already have pages and this cursor was already added as a full page
-        if (pagesLengthRef.current > 0 &&
-            feedCursorEq(lastAddedCursorRef.current ?? null, currentCursor))
-            return;
-        const items = Array.isArray(currentQuery.data?.items)
+        const cursor = currentCursor;
+        const items = Array.isArray(currentQuery.data.items)
             ? currentQuery.data.items
             : [];
-        const limit = options.limit || 20;
-        const nextResult = {
-            hasMore: currentQuery.data.hasMore ?? false,
-            nextCursor: currentQuery.data.nextCursor ?? null,
-        };
-        setLastResult(nextResult);
+        const hasMore = currentQuery.data.hasMore ?? false;
+        const nextCursor = currentQuery.data.nextCursor ?? null;
+        // Only update currentResult for successful response (match dummy)
+        if (items.length === 0 && cursor === null) {
+            // Leave currentResult unchanged on spurious empty first page
+        }
+        else {
+            setCurrentResult({
+                hasMore: hasMore && nextCursor != null,
+                nextCursor,
+            });
+        }
+        if (items.length === 0)
+            return;
+        // Skip merge exactly like dummy: full page already added for this cursor and we have pages
+        if (items.length >= limit &&
+            feedCursorEq(lastAddedCursorRef.current ?? null, cursor) &&
+            pagesLengthRef.current > 0) {
+            return;
+        }
         setPages((prev) => {
-            const existingPage = prev.find((p) => feedCursorEq(p.cursor, currentCursor));
-            if (!existingPage) {
-                if (items.length >= limit) {
-                    lastAddedCursorRef.current = currentCursor;
-                }
-                return [
-                    ...prev,
-                    { cursor: currentCursor, data: items },
-                ];
+            const existingPage = prev.find((p) => feedCursorEq(p.cursor, cursor));
+            const next = !existingPage
+                ? [...prev, { cursor, data: items }]
+                : items.length > existingPage.data.length
+                    ? prev.map((p) => feedCursorEq(p.cursor, cursor) ? { cursor, data: items } : p)
+                    : prev;
+            if (!existingPage && items.length >= limit) {
+                lastAddedCursorRef.current = cursor;
             }
-            return prev;
+            if (existingPage &&
+                items.length > existingPage.data.length &&
+                items.length >= limit) {
+                lastAddedCursorRef.current = cursor;
+            }
+            return next;
         });
-        // Request next page when this response has more (avoids relying on consumer's
-        // IntersectionObserver when sentinel is already in view and callback doesn't re-fire).
-        if (nextResult.hasMore && nextResult.nextCursor != null) {
-            setCurrentCursor(nextResult.nextCursor);
-        }
-    }, [currentQuery.data, currentQuery.isLoading, currentCursor, pages.length, options.limit]);
+    }, [
+        currentQuery.data,
+        currentQuery.isLoading,
+        currentCursor,
+        pages.length,
+        limit,
+    ]);
     const loadMore = useCallback(() => {
-        if (lastResult?.hasMore &&
-            lastResult.nextCursor != null &&
-            !currentQuery.isLoading) {
-            setCurrentCursor(lastResult.nextCursor);
+        if (currentResult?.hasMore &&
+            currentResult.nextCursor != null &&
+            !isLoading) {
+            setCurrentCursor(currentResult.nextCursor);
         }
-    }, [lastResult, currentQuery.isLoading]);
+    }, [currentResult, isLoading]);
     const refetch = useCallback(() => {
         setPages([]);
         setCurrentCursor(null);
+        setCurrentResult(null);
         lastAddedCursorRef.current = undefined;
-        setLastResult(null);
         currentQuery.refetch();
     }, [currentQuery]);
     const allItems = useMemo(() => {
+        const sorted = [...pages].sort((a, b) => {
+            if (feedCursorEq(a.cursor, b.cursor))
+                return 0;
+            if (a.cursor === null)
+                return -1;
+            if (b.cursor === null)
+                return 1;
+            const ta = a.cursor.timestamp ?? '';
+            const tb = b.cursor.timestamp ?? '';
+            return tb.localeCompare(ta);
+        });
         const seen = new Set();
-        return pages.flatMap((p) => p.data).filter((item) => {
+        return sorted.flatMap((p) => p.data).filter((item) => {
             const key = `${item.sort_ts ?? ''}_${item.sort_id ?? ''}_${item.feed_type ?? ''}`;
             if (seen.has(key))
                 return false;
@@ -507,10 +542,10 @@ export const useInfiniteFeedByHerd = (herdId, options) => {
     }, [pages]);
     return {
         items: allItems,
-        isLoading: currentQuery.isLoading && pages.length === 0,
-        isLoadingMore: currentQuery.isLoading && pages.length > 0,
-        hasMore: (lastResult?.hasMore ??
-            (currentCursor !== null && pages.length > 0)) ??
+        isLoading: isLoading && pages.length === 0,
+        isLoadingMore: isLoading && pages.length > 0,
+        hasMore: currentResult?.hasMore ??
+            (currentCursor !== null && pages.length > 0) ??
             false,
         loadMore,
         refetch,

package/package.json

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