@zeniai/client-epic-state 5.2.41 → 5.2.42-betaAK0

package/lib/view/expenseAutomationView/selectorTypes/actualMatchingViewSelectorTypes.d.ts

@@ -0,0 +1,87 @@
+import { Amount } from '../../../commonStateTypes/amount';
+import { FetchStateAndError, ID } from '../../../commonStateTypes/common';
+import { SelectorView } from '../../../commonStateTypes/viewAndReport/viewAndReport';
+import { JEOneTimeAccrual } from '../../../entity/jeSchedules/jeSchedulesSelector';
+import { ZeniDate } from '../../../zeniDayJS';
+import { ActualMatchingTransactionSearchResult, ActualMatchingViewUIState, MatchAndReverseResult } from '../types/actualMatchingViewState';
+export type ActualMatchingRowKind = 'auto_reversed' | 'pending_review' | 'manually_reversed';
+export type ActualMatchingGroupedAccrual = {
+    accrualId: ID;
+    estimatedAmount?: Amount;
+    jeDebitAccountName?: string;
+    memo?: string;
+    serviceMonth?: string;
+};
+export interface ActualMatchingRow extends JEOneTimeAccrual {
+    accruedAmount: Amount;
+    actualAmount: Amount;
+    kind: ActualMatchingRowKind;
+    matchId: string;
+    groupedAccrualIds?: ID[];
+    groupedMembers?: ActualMatchingGroupedAccrual[];
+    intendedAccrualIds?: ID[];
+    leftovers?: ActualMatchingGroupedAccrual[];
+    matchShape?: string;
+    matchTier?: string;
+    reversalDate?: ZeniDate;
+    transactionDate?: string;
+    transactionType?: string;
+}
+export interface ActualMatchingKpiSummary {
+    actualsReceived: {
+        count: number;
+        expectedCount: number;
+        vendorsPending: number;
+    };
+    autoReversed: {
+        clearedAmount: number;
+        count: number;
+        percent: number;
+    };
+    pendingReview: {
+        amount: number;
+        count: number;
+        estimatedMinutesToClear: number;
+    };
+    variance: {
+        averagePercentPerMatch: number;
+        netAmount: number;
+        percent: number;
+    };
+}
+export interface ActualMatchingMatchModalView {
+    accrualSearch: {
+        fetchState: FetchStateAndError;
+        isLoadingMore: boolean;
+        nextPageToken: string | null;
+        query: string;
+        results: JEOneTimeAccrual[];
+    };
+    confirmStatus: FetchStateAndError;
+    isOpen: boolean;
+    transactionSearch: {
+        fetchState: FetchStateAndError;
+        isLoadingMore: boolean;
+        nextPageToken: string | null;
+        query: string;
+        results: ActualMatchingTransactionSearchResult[];
+    };
+    lastBatchResults?: MatchAndReverseResult[];
+    openedFromMatchId?: string;
+    prefill?: {
+        selectedAccrualIds: ID[];
+        actualAmount?: number;
+        consumedLineIds?: ID[];
+        matchedLineId?: string;
+        matchedTransactionId?: string;
+    };
+}
+export interface ExpenseAutomationActualMatchingViewSelector extends SelectorView {
+    hasLoadedForSelectedPeriod: boolean;
+    kpiSummary: ActualMatchingKpiSummary;
+    matchModal: ActualMatchingMatchModalView;
+    pendingReview: ActualMatchingRow[];
+    refreshStatus: FetchStateAndError;
+    reversed: ActualMatchingRow[];
+    uiState: ActualMatchingViewUIState;
+}

package/lib/view/expenseAutomationView/selectorTypes/actualMatchingViewSelectorTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/view/expenseAutomationView/selectorTypes/expenseAutomationViewSelectorTypes.d.ts

@@ -6,6 +6,7 @@ import { MonthEndCloseChecksView } from '../../../view/monthEndCloseChecksView/m
 import { CompanyMonthEndReportSelectorView } from '../../companyMonthEndReportView/companyMonthEndReportViewSelector';
 import { ExpenseAutomationViewType } from '../expenseAutomationViewState';
 import { TransactionsTab } from '../types/transactionsViewState';
+import { ExpenseAutomationActualMatchingViewSelector } from './actualMatchingViewSelectorTypes';
 import { ExpenseAutomationFluxAnalysisViewSelector } from './fluxAnalysisViewSelectorTypes';
 import { ExpenseAutomationJESchedulesViewSelector } from './jeSchedulesSelectorTypes';
 import { ExpenseAutomationMissingReceiptsViewSelector } from './missingReceiptsSelectorTypes';
@@ -21,6 +22,16 @@ export interface ExpenseAutomationStepDetails {
     title: string;
 }
 export interface ExpenseAutomationViewSelector extends SelectorView {
+    /**
+     * Sibling of `jeSchedules`, not nested under it. The Journal Entries navbar
+     * hosts Actual Matching (`selectedPageTab === 'actual_matching'`), but AM is
+     * a different GET, entity map (`byMatchId`), and period cache
+     * (`matchIdsByPeriod`) than Review / Existing. Nesting it on `jeSchedules`
+     * would hide a second store inside the schedules selector. Chrome coupling
+     * stays `jeSchedules.uiState.selectedPageTab`; AM rows, Match New, and undo
+     * live here.
+     */
+    actualMatching: ExpenseAutomationActualMatchingViewSelector;
     allSteps: ExpenseAutomationStepDetails[];
     completionStatus: CompletionStatusType;
     currentSelectedView: ExpenseAutomationViewType;

package/lib/view/expenseAutomationView/selectors/actualMatchingViewSelector.d.ts

@@ -0,0 +1,38 @@
+import { FetchStateAndError } from '../../../commonStateTypes/common';
+import { MonthYearPeriod } from '../../../commonStateTypes/timePeriod';
+import { DisplayCurrencyFallback } from '../../../entity/actualMatching/actualMatchingPayload';
+import { ActualMatchingMatch } from '../../../entity/actualMatching/actualMatchingState';
+import { ActualMatchingMatchId } from '../../../entity/actualMatching/actualMatchingTypes';
+import { JEOneTimeAccrual } from '../../../entity/jeSchedules/jeSchedulesSelector';
+import { JEOneTimeAccrualMatchSuggestion } from '../../../entity/jeSchedules/jeSchedulesState';
+import { RootState } from '../../../rootStateTypes';
+import { ZeniDate } from '../../../zeniDayJS';
+import { ActualMatchingKpiSummary, ActualMatchingRow, ActualMatchingRowKind, ExpenseAutomationActualMatchingViewSelector } from '../selectorTypes/actualMatchingViewSelectorTypes';
+import { MatchAndReverseResult, UndoReversalResult } from '../types/actualMatchingViewState';
+export declare function getSelectedMonthYearForCurrentTenant(state: RootState): MonthYearPeriod | undefined;
+export declare function getTenantDisplayCurrency(state: RootState): DisplayCurrencyFallback | undefined;
+export declare function parseActualMatchingMatchId(matchId: string): {
+    transactionIntegrationId: string;
+    transactionType: string;
+} | null;
+export declare function isAutoReversedAccrual(accrual: JEOneTimeAccrual): boolean;
+export declare function isManuallyReversedAccrual(accrual: JEOneTimeAccrual): boolean;
+export declare function isPendingReviewAccrual(accrual: JEOneTimeAccrual): accrual is JEOneTimeAccrual & {
+    matchSuggestion: JEOneTimeAccrualMatchSuggestion;
+};
+export declare function isReversedMatchKind(kind: ActualMatchingRowKind): boolean;
+export declare function getClearedMatchedAmount(accrual: JEOneTimeAccrual): number | undefined;
+export declare function getActualMatchingAmount(row: ActualMatchingRow): number;
+export declare function getActualMatchingReversalDate(accrual: JEOneTimeAccrual, matchTransactionDate?: string): ZeniDate | undefined;
+export declare function buildActualMatchingKpiSummary(rows: ActualMatchingRow[], displayCurrencyCode?: string): ActualMatchingKpiSummary;
+export interface ExpenseAutomationActualMatchingMatchView {
+    detailFetchState: FetchStateAndError;
+    refreshStatus: FetchStateAndError;
+    undoReversalStatus: FetchStateAndError;
+    lastMatchResults?: MatchAndReverseResult[];
+    lastUndoResults?: UndoReversalResult[];
+    match?: ActualMatchingMatch;
+}
+export declare function getExpenseAutomationActualMatchingMatchView(state: RootState, matchId: ActualMatchingMatchId): ExpenseAutomationActualMatchingMatchView;
+export declare function getCloseMatchAfterUndo(state: RootState): boolean;
+export declare function getExpenseAutomationActualMatchingView(state: RootState): ExpenseAutomationActualMatchingViewSelector;

package/lib/view/expenseAutomationView/selectors/actualMatchingViewSelector.js

@@ -0,0 +1,445 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSelectedMonthYearForCurrentTenant = getSelectedMonthYearForCurrentTenant;
+exports.getTenantDisplayCurrency = getTenantDisplayCurrency;
+exports.parseActualMatchingMatchId = parseActualMatchingMatchId;
+exports.isAutoReversedAccrual = isAutoReversedAccrual;
+exports.isManuallyReversedAccrual = isManuallyReversedAccrual;
+exports.isPendingReviewAccrual = isPendingReviewAccrual;
+exports.isReversedMatchKind = isReversedMatchKind;
+exports.getClearedMatchedAmount = getClearedMatchedAmount;
+exports.getActualMatchingAmount = getActualMatchingAmount;
+exports.getActualMatchingReversalDate = getActualMatchingReversalDate;
+exports.buildActualMatchingKpiSummary = buildActualMatchingKpiSummary;
+exports.getExpenseAutomationActualMatchingMatchView = getExpenseAutomationActualMatchingMatchView;
+exports.getCloseMatchAfterUndo = getCloseMatchAfterUndo;
+exports.getExpenseAutomationActualMatchingView = getExpenseAutomationActualMatchingView;
+const orderBy_1 = __importDefault(require("lodash/orderBy"));
+const timePeriod_1 = require("../../../commonStateTypes/timePeriod");
+const actualMatchingSelector_1 = require("../../../entity/actualMatching/actualMatchingSelector");
+const jeScheduleHelper_1 = require("../../../entity/jeSchedules/jeScheduleHelper");
+const jeSchedulesSelector_1 = require("../../../entity/jeSchedules/jeSchedulesSelector");
+const tenantSelector_1 = require("../../../entity/tenant/tenantSelector");
+const zeniDayJS_1 = require("../../../zeniDayJS");
+const actualMatchingViewState_1 = require("../types/actualMatchingViewState");
+function getSelectedMonthYearForCurrentTenant(state) {
+    const tenantId = (0, tenantSelector_1.getCurrentTenant)(state)?.tenantId;
+    if (tenantId == null) {
+        return undefined;
+    }
+    return state.expenseAutomationViewState.selectedPeriodByTenantId[tenantId];
+}
+function getTenantDisplayCurrency(state) {
+    const locale = (0, tenantSelector_1.getCurrentTenant)(state)?.company?.companyLocaleInfo;
+    if (locale?.currencyCode == null || locale.currencyCode === '') {
+        return undefined;
+    }
+    return {
+        currencyCode: locale.currencyCode,
+        currencySymbol: locale.currencySymbol != null && locale.currencySymbol !== ''
+            ? locale.currencySymbol
+            : locale.currencyCode,
+    };
+}
+function toMatchModalAccrual(member) {
+    if ('jeOneTimeAccrualKey' in member && member.jeOneTimeAccrualKey != null) {
+        return member;
+    }
+    return {
+        ...member,
+        jeOneTimeAccrualKey: (0, jeScheduleHelper_1.generateJEOneTimeAccrualKey)(member.accrualId),
+    };
+}
+function uniqueMatchModalAccruals(pinned, searched) {
+    const byId = new Map();
+    pinned.forEach((row) => byId.set(row.accrualId, row));
+    searched.forEach((row) => {
+        if (!byId.has(row.accrualId)) {
+            byId.set(row.accrualId, row);
+        }
+    });
+    return Array.from(byId.values());
+}
+function uniqueTransactionSearchResults(pinned, searched) {
+    const byKey = new Map();
+    pinned.forEach((row) => byKey.set((0, actualMatchingViewState_1.actualMatchingTransactionLineKey)(row.transactionType, row.transactionIntegrationId, row.lineId), row));
+    searched.forEach((row) => {
+        const key = (0, actualMatchingViewState_1.actualMatchingTransactionLineKey)(row.transactionType, row.transactionIntegrationId, row.lineId);
+        if (!byKey.has(key)) {
+            byKey.set(key, row);
+        }
+    });
+    return Array.from(byKey.values());
+}
+function parseActualMatchingMatchId(matchId) {
+    const separator = matchId.indexOf(':');
+    if (separator <= 0 || separator === matchId.length - 1) {
+        return null;
+    }
+    return {
+        transactionType: matchId.slice(0, separator).toLowerCase(),
+        transactionIntegrationId: matchId.slice(separator + 1),
+    };
+}
+const NOT_STARTED = {
+    fetchState: 'Not-Started',
+    error: undefined,
+};
+function isAutoReversedAccrual(accrual) {
+    return (accrual.accrualStatus === 'reversed' &&
+        accrual.reversalTrigger === 'bill_match');
+}
+function isManuallyReversedAccrual(accrual) {
+    return (accrual.accrualStatus === 'reversed' &&
+        accrual.reversalTrigger === 'manual_reverse');
+}
+function isPendingReviewAccrual(accrual) {
+    if (accrual.accrualStatus !== 'posted' || accrual.matchSuggestion == null) {
+        return false;
+    }
+    const resolution = accrual.matchSuggestion.resolution;
+    return resolution == null || resolution.length === 0;
+}
+function isReversedMatchKind(kind) {
+    return kind === 'auto_reversed' || kind === 'manually_reversed';
+}
+function getClearedMatchedAmount(accrual) {
+    return accrual.cleared?.matchedAmount?.amount;
+}
+function getActualMatchingAmount(row) {
+    return row.actualAmount?.amount ?? row.estimatedAmount.amount;
+}
+function parseMatchTransactionDate(transactionDate) {
+    if (transactionDate == null || transactionDate === '') {
+        return undefined;
+    }
+    const parsed = (0, zeniDayJS_1.date)(transactionDate);
+    return Number.isFinite(parsed.valueOf()) ? parsed : undefined;
+}
+function getActualMatchingReversalDate(accrual, matchTransactionDate) {
+    const matchedDate = isPendingReviewAccrual(accrual)
+        ? accrual.matchSuggestion.matchedTransactionDate
+        : accrual.cleared?.matchedTransactionDate;
+    return matchedDate ?? parseMatchTransactionDate(matchTransactionDate);
+}
+function collectGroupedMembers(members) {
+    if (members.length <= 1) {
+        return undefined;
+    }
+    return members.map((member) => ({
+        accrualId: member.accrualId,
+        estimatedAmount: member.estimatedAmount,
+        jeDebitAccountName: member.jeDebitAccountName,
+        memo: member.memo,
+        serviceMonth: member.serviceMonth,
+    }));
+}
+function collectLeftoverMembers(leftovers) {
+    if (leftovers == null || leftovers.length === 0) {
+        return undefined;
+    }
+    return leftovers.map((member) => ({
+        accrualId: member.accrualId,
+        estimatedAmount: member.estimatedAmount,
+        jeDebitAccountName: member.jeDebitAccountName,
+        memo: member.memo,
+        serviceMonth: member.serviceMonth,
+    }));
+}
+function toActualMatchingRow(match) {
+    const firstMember = match.members[0];
+    if (firstMember == null) {
+        throw new Error('Actual matching row requires at least one member');
+    }
+    const first = toMatchModalAccrual(firstMember);
+    const leftoverMembers = match.leftovers ?? [];
+    const fromCleared = firstMember.cleared?.intendedAccrualIds;
+    const intendedAccrualIds = fromCleared != null && fromCleared.length > 0
+        ? fromCleared
+        : [
+            ...match.members.map((member) => member.accrualId),
+            ...leftoverMembers.map((leftover) => leftover.accrualId),
+        ];
+    return {
+        ...first,
+        matchId: match.matchId,
+        kind: match.kind,
+        accruedAmount: match.accruedAmount,
+        actualAmount: match.actualAmount,
+        matchTier: match.matchTier,
+        matchShape: match.matchShape,
+        transactionType: match.transactionType,
+        transactionDate: match.transactionDate,
+        groupedAccrualIds: match.members.map((member) => member.accrualId),
+        groupedMembers: collectGroupedMembers(match.members),
+        intendedAccrualIds,
+        leftovers: collectLeftoverMembers(match.leftovers),
+        reversalDate: getActualMatchingReversalDate(first, match.transactionDate),
+        vendorName: match.vendorName != null && match.vendorName !== ''
+            ? match.vendorName
+            : first.vendorName,
+        estimatedAmount: match.accruedAmount,
+    };
+}
+function matchesSearch(row, searchString) {
+    const trimmed = searchString.trim().toLowerCase();
+    if (trimmed.length === 0) {
+        return true;
+    }
+    if ((row.vendorName ?? '').toLowerCase().includes(trimmed)) {
+        return true;
+    }
+    if ((row.memo ?? '').toLowerCase().includes(trimmed)) {
+        return true;
+    }
+    return (row.groupedMembers ?? []).some((member) => (member.memo ?? '').toLowerCase().includes(trimmed));
+}
+function getActualMatchingSortValue(row, sortKey) {
+    switch (sortKey) {
+        case 'vendor':
+            return (row.vendorName ?? '').toLowerCase();
+        case 'date': {
+            const millis = row.reversalDate?.valueOf() ??
+                (row.transactionDate != null && row.transactionDate !== ''
+                    ? (0, zeniDayJS_1.date)(row.transactionDate).valueOf()
+                    : 0);
+            return Number.isFinite(millis) ? millis : 0;
+        }
+        case 'amount':
+            return getActualMatchingAmount(row);
+        case 'category':
+            return row.jeDebitAccountName?.toLowerCase();
+        case 'class':
+            return row.jeDebitAccountingClassName?.toLowerCase();
+        case 'type':
+            return row.transactionType?.toLowerCase();
+        case 'lifecycle':
+            return row.kind;
+        case 'service':
+            return row.serviceMonth;
+        case 'accrued':
+            return row.accruedAmount?.amount ?? row.estimatedAmount.amount;
+        case 'actual':
+            return row.actualAmount?.amount;
+        case 'variance': {
+            const accrued = row.accruedAmount?.amount ?? row.estimatedAmount.amount;
+            const actual = row.actualAmount?.amount;
+            if (actual == null || accrued === 0) {
+                return undefined;
+            }
+            return ((actual - accrued) / Math.abs(accrued)) * 100;
+        }
+        default:
+            return undefined;
+    }
+}
+function sortActualMatchingRows(rows, uiState) {
+    const lodashOrder = uiState.sortOrder === 'ascending' ? 'asc' : 'desc';
+    return (0, orderBy_1.default)(rows, [(row) => getActualMatchingSortValue(row, uiState.sortKey)], [lodashOrder]);
+}
+const ESTIMATED_MINUTES_PER_PENDING_MATCH = 4;
+function emptyKpiSummary() {
+    return {
+        actualsReceived: { count: 0, expectedCount: 0, vendorsPending: 0 },
+        autoReversed: { count: 0, percent: 0, clearedAmount: 0 },
+        pendingReview: { count: 0, amount: 0, estimatedMinutesToClear: 0 },
+        variance: { percent: 0, averagePercentPerMatch: 0, netAmount: 0 },
+    };
+}
+function sumRowAmounts(rows, displayCurrencyCode) {
+    return rows.reduce((sum, row) => {
+        if (displayCurrencyCode != null &&
+            row.accruedAmount.currencyCode !== displayCurrencyCode) {
+            return sum;
+        }
+        return sum + getActualMatchingAmount(row);
+    }, 0);
+}
+function isKnownKpiKind(kind) {
+    return (kind === 'auto_reversed' ||
+        kind === 'pending_review' ||
+        kind === 'manually_reversed');
+}
+function rowMatchesDisplayCurrency(row, displayCurrencyCode) {
+    if (displayCurrencyCode == null) {
+        return true;
+    }
+    const rowCurrency = row.accruedAmount?.currencyCode ?? row.estimatedAmount.currencyCode;
+    return rowCurrency === displayCurrencyCode;
+}
+function uniqueVendorCount(rows) {
+    const ids = new Set();
+    rows.forEach((row) => {
+        if (row.vendorId != null && row.vendorId !== '') {
+            ids.add(row.vendorId);
+            return;
+        }
+        if (row.vendorName != null && row.vendorName !== '') {
+            ids.add(row.vendorName);
+        }
+    });
+    return ids.size;
+}
+function rowVariancePercent(row) {
+    const accrued = row.accruedAmount?.amount ?? row.estimatedAmount.amount;
+    const actual = row.actualAmount?.amount;
+    if (actual == null || accrued === 0) {
+        return undefined;
+    }
+    return ((actual - accrued) / Math.abs(accrued)) * 100;
+}
+function buildActualMatchingKpiSummary(rows, displayCurrencyCode) {
+    // Strip counts and amounts share this set: known kinds only, and (when a
+    // display currency is set) that currency only. Lists still render every row.
+    const kpiRows = rows.filter((row) => isKnownKpiKind(row.kind) &&
+        rowMatchesDisplayCurrency(row, displayCurrencyCode));
+    if (kpiRows.length === 0) {
+        return emptyKpiSummary();
+    }
+    const autoReversed = kpiRows.filter((row) => row.kind === 'auto_reversed');
+    const pendingReview = kpiRows.filter((row) => row.kind === 'pending_review');
+    const receivedCount = kpiRows.length;
+    const rowsWithActual = kpiRows.filter((row) => row.actualAmount?.amount != null);
+    const accruedTotal = rowsWithActual.reduce((sum, row) => sum + (row.accruedAmount?.amount ?? row.estimatedAmount.amount), 0);
+    const actualTotal = rowsWithActual.reduce((sum, row) => sum + (row.actualAmount?.amount ?? 0), 0);
+    const variancePercents = kpiRows
+        .map(rowVariancePercent)
+        .filter((percent) => percent != null);
+    return {
+        actualsReceived: {
+            count: receivedCount,
+            // List API does not return still-expected accruals; hide "of N expected"
+            // in the strip until expectedCount is greater than received.
+            expectedCount: receivedCount,
+            vendorsPending: uniqueVendorCount(pendingReview),
+        },
+        autoReversed: {
+            count: autoReversed.length,
+            percent: Math.round((autoReversed.length / receivedCount) * 100),
+            clearedAmount: sumRowAmounts(autoReversed, displayCurrencyCode),
+        },
+        pendingReview: {
+            count: pendingReview.length,
+            amount: sumRowAmounts(pendingReview, displayCurrencyCode),
+            estimatedMinutesToClear: pendingReview.length * ESTIMATED_MINUTES_PER_PENDING_MATCH,
+        },
+        variance: {
+            percent: accruedTotal === 0
+                ? 0
+                : ((actualTotal - accruedTotal) / Math.abs(accruedTotal)) * 100,
+            averagePercentPerMatch: variancePercents.length === 0
+                ? 0
+                : variancePercents.reduce((sum, percent) => sum + percent, 0) /
+                    variancePercents.length,
+            netAmount: actualTotal - accruedTotal,
+        },
+    };
+}
+function getExpenseAutomationActualMatchingMatchView(state, matchId) {
+    const view = state.expenseAutomationActualMatchingViewState;
+    return {
+        match: (0, actualMatchingSelector_1.getActualMatchingMatchById)(state.actualMatchingState, matchId),
+        detailFetchState: view.detailFetchStateByMatchId[matchId] ?? NOT_STARTED,
+        refreshStatus: view.detailRefreshStatusByMatchId[matchId] ?? NOT_STARTED,
+        undoReversalStatus: view.undoReversalStatusByMatchId[matchId] ?? NOT_STARTED,
+        lastMatchResults: view.lastMatchResultsByMatchId?.[matchId],
+        lastUndoResults: view.lastUndoResultsByMatchId?.[matchId],
+    };
+}
+function getCloseMatchAfterUndo(state) {
+    return state.expenseAutomationActualMatchingViewState.closeMatchAfterUndo;
+}
+function getExpenseAutomationActualMatchingView(state) {
+    const { expenseAutomationActualMatchingViewState } = state;
+    const { matchIdsByPeriod, fetchState, error, refreshStatus, uiState, matchModal, } = expenseAutomationActualMatchingViewState;
+    const selectedPeriod = getSelectedMonthYearForCurrentTenant(state);
+    const monthYearPeriodId = selectedPeriod != null ? (0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod) : undefined;
+    const matchIds = monthYearPeriodId != null ? matchIdsByPeriod[monthYearPeriodId] : undefined;
+    const allRows = (matchIds ?? [])
+        .map((matchId) => (0, actualMatchingSelector_1.getActualMatchingMatchById)(state.actualMatchingState, matchId))
+        .filter((match) => match != null)
+        .filter((match) => match.members.length > 0)
+        .map(toActualMatchingRow);
+    const rows = allRows.filter((row) => matchesSearch(row, uiState.searchString));
+    const reversed = sortActualMatchingRows(rows.filter((row) => isReversedMatchKind(row.kind)), uiState);
+    const pendingReview = sortActualMatchingRows(rows.filter((row) => row.kind === 'pending_review'), uiState);
+    const kpiSummary = buildActualMatchingKpiSummary(allRows, getTenantDisplayCurrency(state)?.currencyCode);
+    const searchedAccruals = matchModal.accrualSearch.results
+        .map((key) => (0, jeSchedulesSelector_1.getJEOneTimeAccrualByKey)(key, state.jeSchedulesState))
+        .filter((accrual) => accrual != null);
+    const openedMatch = matchModal.openedFromMatchId != null
+        ? (0, actualMatchingSelector_1.getActualMatchingMatchById)(state.actualMatchingState, matchModal.openedFromMatchId)
+        : undefined;
+    const pinnedAccruals = [
+        ...(openedMatch?.members ?? []),
+        ...(openedMatch?.leftovers ?? []),
+    ].map(toMatchModalAccrual);
+    const firstMember = openedMatch?.members[0];
+    const cleared = firstMember?.cleared;
+    const suggestion = firstMember?.matchSuggestion;
+    const stamp = cleared ?? suggestion;
+    const consumedLineIds = cleared?.consumedLineIds;
+    const prefill = openedMatch == null
+        ? undefined
+        : {
+            selectedAccrualIds: [
+                ...openedMatch.members.map((member) => member.accrualId),
+                ...(openedMatch.leftovers ?? []).map((leftover) => leftover.accrualId),
+            ],
+            actualAmount: openedMatch.actualAmount.amount,
+            matchedTransactionId: stamp?.matchedTransactionId,
+            matchedLineId: cleared == null ? suggestion?.matchedLineId : undefined,
+            ...(consumedLineIds != null && consumedLineIds.length > 0
+                ? { consumedLineIds }
+                : {}),
+        };
+    // `fetchState` is a flat slice field that survives a period switch. Until this
+    // month's ids land, leftover Completed/Error is the previous month. Report
+    // Not-Started so chrome matches Review's "cache slot missing" skeleton, not
+    // empty-complete or a stale error. In-Progress is this month's fetch.
+    const fetchStatus = matchIds == null &&
+        fetchState !== 'In-Progress' &&
+        fetchState !== 'Not-Started'
+        ? { fetchState: 'Not-Started', error: undefined }
+        : { fetchState, error };
+    return {
+        fetchState: fetchStatus.fetchState,
+        error: fetchStatus.error,
+        reversed,
+        pendingReview,
+        kpiSummary,
+        uiState,
+        refreshStatus,
+        hasLoadedForSelectedPeriod: matchIds != null,
+        matchModal: {
+            isOpen: matchModal.isOpen,
+            openedFromMatchId: matchModal.openedFromMatchId,
+            prefill,
+            confirmStatus: matchModal.confirmStatus,
+            lastBatchResults: matchModal.lastBatchResults,
+            transactionSearch: {
+                query: matchModal.transactionSearch.query,
+                results: uniqueTransactionSearchResults(matchModal.pinnedTransactionResults, matchModal.transactionSearch.results),
+                fetchState: {
+                    fetchState: matchModal.transactionSearch.fetchState,
+                    error: matchModal.transactionSearch.error,
+                },
+                nextPageToken: matchModal.transactionSearch.nextPageToken,
+                isLoadingMore: matchModal.transactionSearch.isLoadingMore,
+            },
+            accrualSearch: {
+                query: matchModal.accrualSearch.query,
+                results: uniqueMatchModalAccruals(pinnedAccruals, searchedAccruals),
+                fetchState: {
+                    fetchState: matchModal.accrualSearch.fetchState,
+                    error: matchModal.accrualSearch.error,
+                },
+                nextPageToken: matchModal.accrualSearch.nextPageToken,
+                isLoadingMore: matchModal.accrualSearch.isLoadingMore,
+            },
+        },
+    };
+}

package/lib/view/expenseAutomationView/selectors/jeSchedulesViewSelector.js

@@ -381,6 +381,10 @@ function getExpenseAutomationJESchedulesView(state) {
     // reports undefined rather than 0, so the UI can hide the badge instead of asserting "none".
     const scheduleCountsByTab = {};
     jeSchedulesViewState_1.ALL_JE_PAGE_TABS.forEach((pageTab) => {
+        // AM's badge is `actualMatching.kpiSummary`, not schedule row keys.
+        if (pageTab === 'actual_matching') {
+            return;
+        }
         const periodTabKey = monthYearPeriodId != null
             ? (0, jeSchedulesViewState_1.getJESchedulePeriodTabKey)(pageTab, monthYearPeriodId)
             : null;