Remove one unused function

shubham1206agra · shubham1206agra · commit 1c959e9fe40a · 2026-05-04T18:56:49.000+05:30
diff --git a/src/libs/ReportActionsUtils.ts b/src/libs/ReportActionsUtils.ts
@@ -1663,41 +1663,6 @@ function isNewerReportAction(a: ReportAction, b: ReportAction): boolean {
     return a.reportActionID > b.reportActionID;
 }
 
-/**
- * Finds the newest report action matching each of two filter criteria in a single pass.
- * Returns:
- * - lastVisibleAction: newest visible action
- * - lastActionForDisplay: newest displayable action (not CREATED)
- */
-function findLastReportActions(reportActions: OnyxEntry<ReportActions>, canUserPerformWriteAction?: boolean) {
-    if (!reportActions) {
-        return {lastVisibleAction: undefined, lastActionForDisplay: undefined};
-    }
-
-    let lastVisibleAction: ReportAction | undefined;
-    let lastActionForDisplay: ReportAction | undefined;
-
-    for (const [key, action] of Object.entries(reportActions)) {
-        if (!action) {
-            continue;
-        }
-
-        if (shouldReportActionBeVisible(action, key, canUserPerformWriteAction)) {
-            if (!lastVisibleAction || isNewerReportAction(action, lastVisibleAction)) {
-                lastVisibleAction = action;
-            }
-        }
-
-        if (isReportActionVisibleAsLastAction(action, canUserPerformWriteAction) && action.actionName !== CONST.REPORT.ACTIONS.TYPE.CREATED) {
-            if (!lastActionForDisplay || isNewerReportAction(action, lastActionForDisplay)) {
-                lastActionForDisplay = action;
-            }
-        }
-    }
-
-    return {lastVisibleAction, lastActionForDisplay};
-}
-
 /**
  * The first visible action is the second last action in sortedReportActions which satisfy following conditions:
  * 1. That is not pending deletion as pending deletion actions are kept in sortedReportActions in memory.
@@ -4707,7 +4672,6 @@ export {
     isCardIssuedAction,
     getCardIssuedMessage,
     getRemovedConnectionMessage,
-    findLastReportActions,
     getFilteredReportActionsForReportView,
     wasMessageReceivedWhileOffline,
     shouldShowAddMissingDetails,
diff --git a/tests/unit/ReportActionsUtilsTest.ts b/tests/unit/ReportActionsUtilsTest.ts
@@ -13,7 +13,6 @@ import {chatReportR14932 as mockChatReport, iouReportR14932 as mockIOUReport} fr
 import CONST from '../../src/CONST';
 import * as ReportActionsUtils from '../../src/libs/ReportActionsUtils';
 import {
-    findLastReportActions,
     getAddedCardFeedMessage,
     getAssignedCompanyCardMessage,
     getAutoPayApprovedReportsEnabledMessage,
@@ -4433,135 +4432,6 @@ describe('ReportActionsUtils', () => {
         });
     });
 
-    describe('findLastReportActions', () => {
-        const makeAction = (overrides: Partial<ReportAction>): ReportAction =>
-            ({
-                actionName: CONST.REPORT.ACTIONS.TYPE.ADD_COMMENT,
-                reportActionID: '1',
-                reportID: 'testReportID',
-                created: '2024-01-01 00:00:00.000',
-                person: [{type: 'TEXT', style: 'strong', text: 'Actor'}],
-                message: [{html: 'hello', text: 'hello', type: 'COMMENT'}],
-                ...overrides,
-            }) as ReportAction;
-
-        it('returns undefined for both when reportActions is undefined', () => {
-            const result = findLastReportActions(undefined);
-            expect(result.lastVisibleAction).toBeUndefined();
-            expect(result.lastActionForDisplay).toBeUndefined();
-        });
-
-        it('returns undefined for both when reportActions is empty', () => {
-            const result = findLastReportActions({});
-            expect(result.lastVisibleAction).toBeUndefined();
-            expect(result.lastActionForDisplay).toBeUndefined();
-        });
-
-        it('returns the single visible action for both when there is only one ADD_COMMENT action', () => {
-            const action = makeAction({reportActionID: '1', created: '2024-01-01 00:00:00.000'});
-            const result = findLastReportActions({[action.reportActionID]: action});
-            expect(result.lastVisibleAction).toBe(action);
-            expect(result.lastActionForDisplay).toBe(action);
-        });
-
-        it('returns undefined for lastActionForDisplay but not lastVisibleAction when only action is CREATED', () => {
-            const created = makeAction({actionName: CONST.REPORT.ACTIONS.TYPE.CREATED, reportActionID: '1', created: '2024-01-01 00:00:00.000'});
-            const result = findLastReportActions({[created.reportActionID]: created});
-            expect(result.lastVisibleAction).toBe(created);
-            expect(result.lastActionForDisplay).toBeUndefined();
-        });
-
-        it('returns the newest of multiple visible actions', () => {
-            const older = makeAction({reportActionID: '1', created: '2024-01-01 00:00:00.000'});
-            const newer = makeAction({reportActionID: '2', created: '2024-01-02 00:00:00.000'});
-            const result = findLastReportActions({
-                [older.reportActionID]: older,
-                [newer.reportActionID]: newer,
-            });
-            expect(result.lastVisibleAction).toBe(newer);
-            expect(result.lastActionForDisplay).toBe(newer);
-        });
-
-        it('skips deleted actions (no pendingAction, empty html) for both results', () => {
-            const visible = makeAction({reportActionID: '1', created: '2024-01-01 00:00:00.000'});
-            const deleted = makeAction({
-                reportActionID: '2',
-                created: '2024-01-02 00:00:00.000',
-                message: [{html: '', text: '', type: 'COMMENT'}],
-                pendingAction: undefined,
-            });
-            const result = findLastReportActions({
-                [visible.reportActionID]: visible,
-                [deleted.reportActionID]: deleted,
-            });
-            expect(result.lastVisibleAction).toBe(visible);
-            expect(result.lastActionForDisplay).toBe(visible);
-        });
-
-        it('excludes actions with errors from lastActionForDisplay but not from lastVisibleAction', () => {
-            const clean = makeAction({reportActionID: '1', created: '2024-01-01 00:00:00.000'});
-            const withErrors = makeAction({
-                reportActionID: '2',
-                created: '2024-01-02 00:00:00.000',
-                errors: {someError: 'error message'},
-            });
-            const result = findLastReportActions({
-                [clean.reportActionID]: clean,
-                [withErrors.reportActionID]: withErrors,
-            });
-            expect(result.lastVisibleAction).toBe(withErrors);
-            expect(result.lastActionForDisplay).toBe(clean);
-        });
-
-        it('agrees with getSortedReportActionsForDisplay for lastVisibleAction across multiple actions', () => {
-            const actionA = makeAction({reportActionID: 'actionA', created: '2024-01-01 00:00:00.000'});
-            const actionB = makeAction({reportActionID: 'actionB', created: '2024-01-03 00:00:00.000'});
-            const actionC = makeAction({reportActionID: 'actionC', created: '2024-01-02 00:00:00.000'});
-            const actions: ReportActions = {
-                actionA,
-                actionB,
-                actionC,
-            };
-            const {lastVisibleAction} = findLastReportActions(actions);
-            const fromSort = getSortedReportActionsForDisplay(actions).at(0);
-            expect(lastVisibleAction?.reportActionID).toBe(fromSort?.reportActionID);
-        });
-
-        it('agrees with the old getSortedReportActions+filter approach for lastActionForDisplay', () => {
-            const actionA = makeAction({reportActionID: 'actionA', created: '2024-01-01 00:00:00.000'});
-            const actionB = makeAction({reportActionID: 'actionB', created: '2024-01-03 00:00:00.000'});
-            const actionC = makeAction({
-                reportActionID: 'actionC',
-                created: '2024-01-02 00:00:00.000',
-                errors: {someError: 'error'},
-            });
-            const actions: ReportActions = {actionA, actionB, actionC};
-            const {lastActionForDisplay} = findLastReportActions(actions);
-            const fromOldApproach = getSortedReportActions(Object.values(actions)).findLast(
-                (a) => isReportActionVisibleAsLastAction(a) && a.actionName !== CONST.REPORT.ACTIONS.TYPE.CREATED,
-            );
-            expect(lastActionForDisplay?.reportActionID).toBe(fromOldApproach?.reportActionID);
-        });
-
-        it('respects canUserPerformWriteAction when determining visibility', () => {
-            const normalAction = makeAction({reportActionID: '1', created: '2024-01-01 00:00:00.000'});
-            // An actionable mention whisper is hidden when canUserPerformWriteAction is false
-            const joinRequestAction = makeAction({
-                reportActionID: '2',
-                created: '2024-01-02 00:00:00.000',
-                actionName: CONST.REPORT.ACTIONS.TYPE.ACTIONABLE_MENTION_WHISPER,
-            });
-
-            const withWrite = findLastReportActions({[normalAction.reportActionID]: normalAction, [joinRequestAction.reportActionID]: joinRequestAction}, true);
-            const withoutWrite = findLastReportActions({[normalAction.reportActionID]: normalAction, [joinRequestAction.reportActionID]: joinRequestAction}, false);
-
-            // With write permission: join request is visible, so it should be selected as newer
-            expect(withWrite.lastVisibleAction?.reportActionID).toBe(joinRequestAction.reportActionID);
-            // Without write permission: join request hidden, so only the normal action remains
-            expect(withoutWrite.lastVisibleAction?.reportActionID).toBe(normalAction.reportActionID);
-        });
-    });
-
     describe('isOriginalReportDeleted', () => {
         it('should return true when action.isOriginalReportDeleted is true', () => {
             const action = {
