Merge branch 'main' into feat/migrate-category-selector-to-navigation

Author: jmusial

src/ROUTES.ts

@@ -1236,6 +1236,11 @@ const ROUTES = {
             return `${action as string}/${iouType as string}/start/${transactionID}/${reportID}` as const;
         },
     },
+    MONEY_REQUEST_CREATE_VERIFY_ACCOUNT: {
+        route: `:action/:iouType/start/:transactionID/:reportID/${VERIFY_ACCOUNT}`,
+        getRoute: (action: IOUAction, iouType: IOUType, transactionID: string, reportID: string) =>
+            `${action as string}/${iouType as string}/start/${transactionID}/${reportID}/${VERIFY_ACCOUNT}` as const,
+    },
     MONEY_REQUEST_STEP_SEND_FROM: {
         route: 'create/:iouType/from/:transactionID/:reportID',
 

src/SCREENS.ts

@@ -344,6 +344,7 @@ const SCREENS = {
 
     MONEY_REQUEST: {
         CREATE: 'Money_Request_Create',
+        CREATE_VERIFY_ACCOUNT: 'Money_Request_Create_Verify_Account',
         HOLD: 'Money_Request_Hold_Reason',
         REJECT: 'Money_Request_Reject_Reason',
         REPORT_REJECT: 'Money_Request_Report_Reject',

src/components/MigratedUserWelcomeModal.tsx

@@ -11,8 +11,11 @@ import {openExternalLink} from '@libs/actions/Link';
 import {dismissProductTraining} from '@libs/actions/Welcome';
 import convertToLTR from '@libs/convertToLTR';
 import Log from '@libs/Log';
+import Navigation from '@libs/Navigation/Navigation';
+import {buildCannedSearchQuery} from '@libs/SearchQueryUtils';
 import variables from '@styles/variables';
 import CONST from '@src/CONST';
+import ROUTES from '@src/ROUTES';
 import type {FeatureListItem} from './FeatureList';
 import FeatureTrainingModal from './FeatureTrainingModal';
 import Icon from './Icon';
@@ -58,6 +61,7 @@ function MigratedUserWelcomeModal() {
     const onClose = () => {
         Log.hmmm('[MigratedUserWelcomeModal] onClose called, dismissing product training');
         dismissProductTraining(CONST.MIGRATED_USER_WELCOME_MODAL);
+        Navigation.navigate(ROUTES.SEARCH_ROOT.getRoute({query: buildCannedSearchQuery({type: CONST.SEARCH.DATA_TYPES.EXPENSE_REPORT})}));
     };
 
     const featureListContent = (

src/components/ReferralProgramCTA.tsx

@@ -64,6 +64,7 @@ function ReferralProgramCTA({referralContentType, style, onDismiss}: ReferralPro
             {/* Hidden from accessibility — the CTA pressable above already announces this content. */}
             <View
                 aria-hidden
+                pointerEvents="none"
                 style={[styles.flex1, styles.flexRow, styles.alignItemsCenter]}
             >
                 <RenderHTML html={translate(`referralProgram.${referralContentType}.buttonText`)} />

src/components/Search/SearchPageHeader/useSearchFiltersBar.tsx

@@ -60,6 +60,7 @@ const SKIPPED_FILTERS = new Set<SearchAdvancedFiltersKey>([
     FILTER_KEYS.VIEW,
     FILTER_KEYS.PAYER,
     FILTER_KEYS.ACTION,
+    FILTER_KEYS.COLUMNS,
 ]);
 
 function getFilterSentryLabel(filterKey: SearchAdvancedFiltersKey | SearchFilterKey | ReportFieldKey) {

src/hooks/useDefaultExpensePolicy.tsx

@@ -1,17 +1,50 @@
+import type {OnyxCollection} from 'react-native-onyx';
 import {isPaidGroupPolicy, isPolicyAccessible} from '@libs/PolicyUtils';
 import ONYXKEYS from '@src/ONYXKEYS';
+import type {Policy} from '@src/types/onyx';
 import useCurrentUserPersonalDetails from './useCurrentUserPersonalDetails';
 import useOnyx from './useOnyx';
 import usePreferredPolicy from './usePreferredPolicy';
 
+/**
+ * Selector that finds the single qualifying group policy ID from the collection.
+ * Returns only an ID (stable) — prevents re-renders when unrelated policies change.
+ */
+function getSingleGroupPolicyID(policies: OnyxCollection<Policy>, login: string): string | undefined {
+    if (!policies) {
+        return undefined;
+    }
+
+    let singlePolicyID: string | undefined;
+    for (const policy of Object.values(policies)) {
+        if (!policy || !isPaidGroupPolicy(policy) || !isPolicyAccessible(policy, login)) {
+            continue;
+        }
+        if (!singlePolicyID) {
+            singlePolicyID = policy.id;
+        } else {
+            return undefined; // More than one — no single default
+        }
+    }
+
+    return singlePolicyID;
+}
+
 export default function useDefaultExpensePolicy() {
     const [activePolicyID] = useOnyx(ONYXKEYS.NVP_ACTIVE_POLICY_ID);
     const [activePolicy] = useOnyx(`${ONYXKEYS.COLLECTION.POLICY}${activePolicyID}`);
-    const [allPolicies] = useOnyx(ONYXKEYS.COLLECTION.POLICY);
     const {isRestrictedToPreferredPolicy, preferredPolicyID} = usePreferredPolicy();
     const {login = ''} = useCurrentUserPersonalDetails();
     const [preferredPolicy] = useOnyx(`${ONYXKEYS.COLLECTION.POLICY}${preferredPolicyID}`);
 
+    // Selector returns only the qualifying policy ID — stable value, prevents re-renders
+    const [singleGroupPolicyID] = useOnyx(ONYXKEYS.COLLECTION.POLICY, {
+        selector: (policies) => getSingleGroupPolicyID(policies, login),
+    });
+
+    // Per-key lookup for the single group policy (only fires when that specific policy changes)
+    const [singleGroupPolicy] = useOnyx(`${ONYXKEYS.COLLECTION.POLICY}${singleGroupPolicyID}`);
+
     if (isRestrictedToPreferredPolicy && isPaidGroupPolicy(preferredPolicy) && isPolicyAccessible(preferredPolicy, login)) {
         return preferredPolicy;
     }
@@ -20,20 +53,5 @@ export default function useDefaultExpensePolicy() {
         return activePolicy;
     }
 
-    // If there is exactly one group policy, use that as the default expense policy
-    let singlePolicy;
-    for (const policy of Object.values(allPolicies ?? {})) {
-        if (!policy || !isPaidGroupPolicy(policy) || !isPolicyAccessible(policy, login)) {
-            continue;
-        }
-
-        if (!singlePolicy) {
-            singlePolicy = policy;
-        } else {
-            singlePolicy = undefined;
-            break;
-        }
-    }
-
-    return singlePolicy;
+    return singleGroupPolicy;
 }

src/hooks/usePolicyForMovingExpenses.ts

@@ -1,5 +1,5 @@
 import {activePolicySelector} from '@selectors/Policy';
-import type {OnyxEntry} from 'react-native-onyx';
+import type {OnyxCollection, OnyxEntry} from 'react-native-onyx';
 import {useSession} from '@components/OnyxListItemProvider';
 import {canSubmitPerDiemExpenseFromWorkspace, isPaidGroupPolicy, isPolicyMemberWithoutPendingDelete, isTimeTrackingEnabled} from '@libs/PolicyUtils';
 import CONST from '@src/CONST';
@@ -31,48 +31,85 @@ function isPolicyValidForMovingExpenses(policy: OnyxEntry<Policy>, login: string
     );
 }
 
-function usePolicyForMovingExpenses(isPerDiemRequest?: boolean, isTimeRequest?: boolean, expensePolicyID?: string) {
-    const [allPolicies] = useOnyx(ONYXKEYS.COLLECTION.POLICY);
-    const [activePolicyID] = useOnyx(ONYXKEYS.NVP_ACTIVE_POLICY_ID);
-    const [activePolicy] = useOnyx(`${ONYXKEYS.COLLECTION.POLICY}${activePolicyID}`, {
-        selector: activePolicySelector,
-    });
+type PolicyQualificationResult = {
+    singlePolicyID: string | undefined;
+    isMemberOfMoreThanOnePolicy: boolean;
+    validExpensePolicyID: string | undefined;
+};
 
-    const session = useSession();
-    const login = session?.email ?? '';
+/**
+ * Selector that computes which policies qualify for moving expenses.
+ * Returns only IDs and flags — stable output that prevents re-renders when unrelated policies change.
+ */
+function getPolicyQualificationResult(
+    policies: OnyxCollection<Policy>,
+    login: string,
+    isPerDiemRequest?: boolean,
+    isTimeRequest?: boolean,
+    expensePolicyID?: string,
+): PolicyQualificationResult {
+    if (!policies) {
+        return {singlePolicyID: undefined, isMemberOfMoreThanOnePolicy: false, validExpensePolicyID: undefined};
+    }
 
-    // Early exit optimization: only need to check if we have 0, 1, or >1 policies
-    let singleUserPolicy;
+    let singlePolicyID: string | undefined;
     let isMemberOfMoreThanOnePolicy = false;
-    for (const policy of Object.values(allPolicies ?? {})) {
+    for (const policy of Object.values(policies)) {
         if (!isPolicyValidForMovingExpenses(policy, login, isPerDiemRequest, isTimeRequest)) {
             continue;
         }
-
-        if (!singleUserPolicy) {
-            singleUserPolicy = policy;
+        if (!singlePolicyID) {
+            singlePolicyID = policy?.id;
         } else {
             isMemberOfMoreThanOnePolicy = true;
-            break; // Found 2, no need to continue
+            break;
         }
     }
 
-    // If an expense policy ID is provided and valid, prefer it over the active policy
-    // This ensures that when viewing/editing an expense from workspace B, we show workspace B
-    // even if the user's default workspace is A
+    let validExpensePolicyID: string | undefined;
     if (expensePolicyID) {
-        const expensePolicy = allPolicies?.[`${ONYXKEYS.COLLECTION.POLICY}${expensePolicyID}`];
+        const expensePolicy = policies[`${ONYXKEYS.COLLECTION.POLICY}${expensePolicyID}`];
         if (expensePolicy && isPolicyValidForMovingExpenses(expensePolicy, login, isPerDiemRequest, isTimeRequest)) {
-            return {policyForMovingExpensesID: expensePolicyID, policyForMovingExpenses: expensePolicy, shouldSelectPolicy: false};
+            validExpensePolicyID = expensePolicyID;
         }
     }
 
+    return {singlePolicyID, isMemberOfMoreThanOnePolicy, validExpensePolicyID};
+}
+
+function usePolicyForMovingExpenses(isPerDiemRequest?: boolean, isTimeRequest?: boolean, expensePolicyID?: string) {
+    const [activePolicyID] = useOnyx(ONYXKEYS.NVP_ACTIVE_POLICY_ID);
+    const [activePolicy] = useOnyx(`${ONYXKEYS.COLLECTION.POLICY}${activePolicyID}`, {
+        selector: activePolicySelector,
+    });
+
+    const session = useSession();
+    const login = session?.email ?? '';
+
+    // Contextual selector — captures login/flags from closure.
+    // Returns only IDs + flags (stable output) to prevent re-renders when unrelated policies change.
+    const policyQualificationSelector = (policies: OnyxCollection<Policy>) => getPolicyQualificationResult(policies, login, isPerDiemRequest, isTimeRequest, expensePolicyID);
+    const [qualificationResult] = useOnyx(ONYXKEYS.COLLECTION.POLICY, {
+        selector: policyQualificationSelector,
+    });
+
+    const {singlePolicyID, isMemberOfMoreThanOnePolicy, validExpensePolicyID} = qualificationResult ?? {};
+
+    // Per-key lookup for the resolved policy (only fires when that specific policy changes)
+    const resolvedPolicyID = validExpensePolicyID ?? singlePolicyID;
+    const [resolvedPolicy] = useOnyx(`${ONYXKEYS.COLLECTION.POLICY}${resolvedPolicyID}`);
+
+    // If an expense policy ID is provided and valid, prefer it over the active policy
+    if (validExpensePolicyID) {
+        return {policyForMovingExpensesID: validExpensePolicyID, policyForMovingExpenses: resolvedPolicy, shouldSelectPolicy: false};
+    }
+
     if (activePolicy && (!isPerDiemRequest || canSubmitPerDiemExpenseFromWorkspace(activePolicy)) && (!isTimeRequest || isTimeTrackingEnabled(activePolicy))) {
         return {policyForMovingExpensesID: activePolicyID, policyForMovingExpenses: activePolicy, shouldSelectPolicy: false};
     }
 
-    if (singleUserPolicy && !isMemberOfMoreThanOnePolicy) {
-        return {policyForMovingExpensesID: singleUserPolicy.id, policyForMovingExpenses: singleUserPolicy, shouldSelectPolicy: false};
+    if (singlePolicyID && !isMemberOfMoreThanOnePolicy) {
+        return {policyForMovingExpensesID: singlePolicyID, policyForMovingExpenses: resolvedPolicy, shouldSelectPolicy: false};
     }
 
     if (isMemberOfMoreThanOnePolicy) {

src/hooks/useReportAttributes.ts

@@ -14,4 +14,18 @@ function useReportAttributes() {
     return reportAttributes?.reports;
 }
 
+/**
+ * Returns a single report's attributes using a selector.
+ * Deep comparison is cheap (single small object), so re-renders only occur
+ * when that specific report's attributes change — not on every global report change.
+ */
+function useReportAttributesByID(reportID: string | undefined) {
+    const reportAttributesByIDSelector = (value: {reports?: Record<string, unknown>} | undefined) => (reportID ? value?.reports?.[reportID] : undefined);
+    const [reportAttributes] = useOnyx(ONYXKEYS.DERIVED.REPORT_ATTRIBUTES, {
+        selector: reportAttributesByIDSelector,
+    });
+    return reportAttributes;
+}
+
 export default useReportAttributes;
+export {useReportAttributesByID};

src/hooks/useReportIsArchived.ts

@@ -2,10 +2,13 @@ import {isArchivedReport} from '@libs/ReportUtils';
 import ONYXKEYS from '@src/ONYXKEYS';
 import useOnyx from './useOnyx';
 
+const isArchivedSelector = isArchivedReport;
+
 function useReportIsArchived(reportID?: string): boolean {
-    const [reportNameValuePairs] = useOnyx(`${ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS}${reportID}`);
-    const isReportArchived = isArchivedReport(reportNameValuePairs);
-    return isReportArchived;
+    const [isArchived] = useOnyx(`${ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS}${reportID}`, {
+        selector: isArchivedSelector,
+    });
+    return !!isArchived;
 }
 
 export default useReportIsArchived;

src/hooks/useSearchBulkActions.ts

@@ -1029,17 +1029,19 @@ function useSearchBulkActions({queryJSON}: UseSearchBulkActionsParams) {
                 shouldCallAfterModalHide: true,
             });
 
-            for (const template of exportTemplates) {
-                exportOptions.push({
-                    text: template.name,
-                    icon: expensifyIcons.Table,
-                    description: template.description,
-                    onSelected: () => {
-                        beginExportWithTemplate(template.templateName, template.type, template.policyID);
-                    },
-                    shouldCloseModalOnSelect: true,
-                    shouldCallAfterModalHide: true,
-                });
+            if (!allSelectedAreDeleted) {
+                for (const template of exportTemplates) {
+                    exportOptions.push({
+                        text: template.name,
+                        icon: expensifyIcons.Table,
+                        description: template.description,
+                        onSelected: () => {
+                            beginExportWithTemplate(template.templateName, template.type, template.policyID);
+                        },
+                        shouldCloseModalOnSelect: true,
+                        shouldCallAfterModalHide: true,
+                    });
+                }
             }
 
             return exportOptions;