Merge pull request Expensify#94817 from callstack-internal/decompose/ral-11

Decompose ReportActionsList: 11

Author: rlinoz

src/hooks/useUnreadMarker.ts

@@ -13,16 +13,30 @@ import useOnyx from './useOnyx';
 import usePrevious from './usePrevious';
 
 type UseUnreadMarkerParams = {
+    /** The report whose unread marker is being computed */
     reportID: string;
+
+    /** The visible actions (FlatList `data` domain, newest-first) that the marker scan runs over */
     sortedVisibleReportActions: OnyxTypes.ReportAction[];
+
+    /** All sorted actions (the full chain); used to find the earliest-received-while-offline message index */
     sortedReportActions: OnyxTypes.ReportAction[];
+
+    /** The oldest unread action id used as the pagination anchor for marker placement before actions have fully loaded */
     oldestUnreadReportActionID: string | undefined;
+
+    /** Whether the list is scrolled past the threshold where incoming actions are treated as out of view */
     isScrolledOverThreshold: boolean;
+
+    /** Whether report actions have loaded at least once; once true, the pagination anchor is ignored in favor of the scan */
     hasOnceLoadedReportActions: boolean;
 };
 
 type UseUnreadMarkerResult = {
+    /** The reportActionID the unread marker should render above, or `null` if none qualifies */
     unreadMarkerReportActionID: string | null;
+
+    /** Index of that action within `sortedVisibleReportActions`, or `-1` if none */
     unreadMarkerReportActionIndex: number;
 };
 
@@ -48,12 +62,6 @@ function useUnreadMarker({
 
     const [unreadMarkerTime, setUnreadMarkerTime] = useState(reportLastReadTime);
 
-    const [trackedReportID, setTrackedReportID] = useState(reportID);
-    if (trackedReportID !== reportID) {
-        setTrackedReportID(reportID);
-        setUnreadMarkerTime(reportLastReadTime);
-    }
-
     if (unreadMarkerTime === '' && reportLastReadTime !== '') {
         setUnreadMarkerTime(reportLastReadTime);
     }

tests/unit/ReportActionsUtilsTest.ts

@@ -5576,6 +5576,18 @@ describe('ReportActionsUtils', () => {
                 }),
             ).toEqual(['unread-newer', 1]);
         });
+
+        it("clears the marker entirely when the only unread action is the current user's own new message", () => {
+            const ownNew = makeAction({reportActionID: 'own-new', actorAccountID: currentUserAccountID});
+            const olderRead = makeAction({reportActionID: 'older-read', created: '2023-01-01 09:00:00.000'});
+            expect(
+                getUnreadMarkerReportAction({
+                    ...baseScanParams,
+                    visibleReportActions: [ownNew, olderRead],
+                    prevSortedVisibleReportActionsObjects: {},
+                }),
+            ).toEqual([null, -1]);
+        });
     });
 
     describe('getIntegrationSyncFailedMessage', () => {

tests/unit/useUnreadMarkerTest.ts

@@ -1,6 +1,7 @@
 import {act, renderHook} from '@testing-library/react-native';
 import {DeviceEventEmitter} from 'react-native';
 import useUnreadMarker from '@hooks/useUnreadMarker';
+import ONYXKEYS from '@src/ONYXKEYS';
 import type * as OnyxTypes from '@src/types/onyx';
 import {getFakeReportAction} from '../utils/ReportTestUtils';
 
@@ -11,6 +12,7 @@ const LAST_READ_TIME = '2023-01-01 10:00:00.000';
 
 let mockIsAnonymousUser = false;
 let mockLastReadTime: string = LAST_READ_TIME;
+let mockLastReadTimeByReportID: Record<string, string> = {};
 
 jest.mock('@hooks/useCurrentUserPersonalDetails', () => ({
     __esModule: true,
@@ -22,9 +24,13 @@ jest.mock('@hooks/useIsAnonymousUser', () => ({
     default: () => mockIsAnonymousUser,
 }));
 
+// The hook subscribes to `${ONYXKEYS.COLLECTION.REPORT}${reportID}` with a selector that returns
+// `lastReadTime`. The implementation is set in beforeEach so it can use ONYXKEYS freely (a jest.mock
+// factory cannot reference out-of-scope variables).
+const mockUseOnyx = jest.fn<[string], [string]>();
 jest.mock('@hooks/useOnyx', () => ({
     __esModule: true,
-    default: () => [mockLastReadTime],
+    default: (key: string) => mockUseOnyx(key),
 }));
 
 function makeAction(reportActionID: string, overrides: Partial<OnyxTypes.ReportAction> = {}): OnyxTypes.ReportAction {
@@ -55,6 +61,11 @@ describe('useUnreadMarker', () => {
     beforeEach(() => {
         mockIsAnonymousUser = false;
         mockLastReadTime = LAST_READ_TIME;
+        mockLastReadTimeByReportID = {};
+        mockUseOnyx.mockImplementation((key) => {
+            const reportID = key.replace(ONYXKEYS.COLLECTION.REPORT, '');
+            return [mockLastReadTimeByReportID[reportID] ?? mockLastReadTime];
+        });
     });
 
     it('returns [null, -1] for an anonymous user', () => {
@@ -107,4 +118,24 @@ describe('useUnreadMarker', () => {
         expect(result.current.unreadMarkerReportActionID).toBeNull();
         expect(result.current.unreadMarkerReportActionIndex).toBe(-1);
     });
+
+    it('seeds the marker from the switched-to report lastReadTime (one mount per report)', () => {
+        // Setup: report 'A' was last read at 10:00 and 'B' at 12:00; one action from another user lands
+        // at 11:00 — after A's read time (unread on A) but before B's read time (already read on B).
+        mockLastReadTimeByReportID = {
+            A: '2023-01-01 10:00:00.000',
+            B: '2023-01-01 12:00:00.000',
+        };
+        const action = makeAction('msg', {created: '2023-01-01 11:00:00.000'});
+
+        // Mounted on A: 11:00 is after A's 10:00 read time → unread → marker lands on the action.
+        const {result: resultA} = renderUnreadMarker({reportID: 'A', sortedVisibleReportActions: [action], sortedReportActions: [action]});
+        expect(resultA.current.unreadMarkerReportActionID).toBe('msg');
+        expect(resultA.current.unreadMarkerReportActionIndex).toBe(0);
+
+        // Mounted on B: 11:00 is before B's 12:00 read time → already read → no marker.
+        const {result: resultB} = renderUnreadMarker({reportID: 'B', sortedVisibleReportActions: [action], sortedReportActions: [action]});
+        expect(resultB.current.unreadMarkerReportActionID).toBeNull();
+        expect(resultB.current.unreadMarkerReportActionIndex).toBe(-1);
+    });
 });