@zeniai/client-epic-state 4.20.7 → 4.20.8

package/lib/esm/view/expenseAutomationView/epics/missingReceipts/restoreBulkUploadAutomatchingOnMountEpic.js

@@ -0,0 +1,98 @@
+import { EMPTY, concat, from, of } from 'rxjs';
+import { catchError, concatMap, filter, mergeMap, take } from 'rxjs/operators';
+import { isSuccessResponse } from '../../../../responsePayload';
+import { isBatchDetailsStatusPendingOrProcessing, toBatchListItem, } from '../../payload/missingReceiptsPayload';
+import { fetchBulkUploadBatchesSuccess, restoreBulkUploadAutomatchingOnMount, restoreBulkUploadMatchingState, } from '../../reducers/missingReceiptsViewReducer';
+import { BULK_UPLOAD_BATCH_LIST_DATE_RANGE_DAYS } from '../../helpers/bulkUploadTiming';
+import { rollingCalendarDateRangeInclusive } from '../../helpers/rollingCalendarDateRangeInclusive';
+import { toMonthYearPeriodId } from '../../../../commonStateTypes/timePeriod';
+import { getCurrentTenant } from '../../../../entity/tenant/tenantSelector';
+/**
+ * On missing-receipts entry / period switch, hydrate the automatching banner for the logged-in
+ * user without relying on UI-driven list fetches (the Missing tab does not fetch the batch list
+ * while `phase === 'idle'`). Flow:
+ *  1. Call `GET /1.0/batches` (rolling 30-day window).
+ *  2. Emit `fetchBulkUploadBatchesSuccess` so `batchListByPeriod` is populated for the selected
+ *     period (prevents a duplicate list fetch when the user switches to the Unmatched tab).
+ *  3. For each `processing|pending` row, call `GET /1.0/batches/:id` in order; for the first row
+ *     whose details `user_id` matches the logged-in user and whose status is still
+ *     pending/processing, dispatch `restoreBulkUploadMatchingState` and stop.
+ */
+export const restoreBulkUploadAutomatchingOnMountEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(restoreBulkUploadAutomatchingOnMount.match), mergeMap(() => {
+    const state = state$.value;
+    const { expenseAutomationMissingReceiptsViewState: { bulkUpload }, expenseAutomationViewState: { selectedPeriodByTenantId }, } = state;
+    if (bulkUpload.phase !== 'idle') {
+        return EMPTY;
+    }
+    if (bulkUpload.batchListFetchState.fetchState === 'In-Progress') {
+        return EMPTY;
+    }
+    const loggedInUserId = state.tenantState.loggedInUser?.userId;
+    if (loggedInUserId == null) {
+        return EMPTY;
+    }
+    const currentTenant = getCurrentTenant(state);
+    const selectedPeriod = selectedPeriodByTenantId[currentTenant.tenantId];
+    if (selectedPeriod == null) {
+        return EMPTY;
+    }
+    const { end, start } = rollingCalendarDateRangeInclusive(BULK_UPLOAD_BATCH_LIST_DATE_RANGE_DAYS);
+    const queryParam = {
+        start_date: start,
+        end_date: end,
+        sort_order: 'desc',
+    };
+    const listUrl = `${zeniAPI.apiEndPoints.communicationAgentMicroServiceBaseUrl}/1.0/batches?query=${encodeURIComponent(JSON.stringify(queryParam))}`;
+    const detailsBaseUrl = `${zeniAPI.apiEndPoints.communicationAgentMicroServiceBaseUrl}/1.0/batches/`;
+    const periodId = toMonthYearPeriodId(selectedPeriod);
+    const alreadyCached = (bulkUpload.batchListByPeriod[periodId] ?? []).length > 0 &&
+        bulkUpload.batchListFetchState.fetchState === 'Completed';
+    const listSource = alreadyCached
+        ? of(null)
+        : zeniAPI.getJSON(listUrl).pipe(catchError(() => of(null)));
+    return listSource.pipe(mergeMap((listResponse) => {
+        const batchList = alreadyCached
+            ? bulkUpload.batchListByPeriod[periodId] ?? []
+            : listResponse != null &&
+                isSuccessResponse(listResponse) &&
+                listResponse.data != null
+                ? listResponse.data.batches.map(toBatchListItem)
+                : null;
+        if (batchList == null) {
+            return EMPTY;
+        }
+        const successAction = alreadyCached
+            ? null
+            : fetchBulkUploadBatchesSuccess({
+                batchList,
+                selectedPeriod,
+            });
+        const processingBatches = batchList.filter((b) => {
+            const status = b.status.toLowerCase();
+            return status === 'processing' || status === 'pending';
+        });
+        const restoreStream = from(processingBatches).pipe(concatMap((batch) => zeniAPI
+            .getJSON(`${detailsBaseUrl}${batch.batchId}`)
+            .pipe(mergeMap((response) => {
+            if (!isSuccessResponse(response) || response.data == null) {
+                return EMPTY;
+            }
+            const data = response.data;
+            const detailsUserId = data.user_id;
+            if (detailsUserId == null ||
+                detailsUserId !== loggedInUserId) {
+                return EMPTY;
+            }
+            if (!isBatchDetailsStatusPendingOrProcessing(data.status)) {
+                return EMPTY;
+            }
+            return of(restoreBulkUploadMatchingState({
+                batchId: batch.batchId,
+                totalFiles: batch.totalFiles,
+            }));
+        }), catchError(() => EMPTY))), take(1));
+        return successAction != null
+            ? concat(of(successAction), restoreStream)
+            : restoreStream;
+    }));
+}));

package/lib/esm/view/expenseAutomationView/epics/missingReceipts/searchTransactionsForManualMatchEpic.js

@@ -0,0 +1,71 @@
+import { EMPTY, from, merge, of } from 'rxjs';
+import { catchError, debounceTime, filter, mergeMap, switchMap, } from 'rxjs/operators';
+import { updateTransactions } from '../../../../entity/transaction/transactionReducer';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { supportedTransactionPayloadToManualSearchResult } from '../../payload/missingReceiptsPayload';
+import { searchTransactionsForManualMatch, searchTransactionsForManualMatchFailure, searchTransactionsForManualMatchSuccess, } from '../../reducers/missingReceiptsViewReducer';
+import { toTransactionsSortKey } from '../../types/transactionsViewState';
+import { rollingCalendarDateRangeInclusive } from '../../helpers/rollingCalendarDateRangeInclusive';
+/**
+ * `auto_categorized` for manual transaction search (Unmatched).
+ * Backend contract TBD — align with `fetchTransactionCategorizationEpic` (`selectedTab === 'autoCategorized'`)
+ * when the expense-automation API documents the intended filter for this flow.
+ */
+export const MANUAL_TRANSACTION_SEARCH_AUTO_CATEGORIZED = false;
+/** Inclusive rolling window for manual match search (ignores accounting period picker). */
+const MANUAL_SEARCH_TRANSACTION_DATE_RANGE_DAYS = 90;
+export const searchTransactionsForManualMatchEpic = (actions$, state$, zeniAPI) => {
+    const searchActions$ = actions$.pipe(filter(searchTransactionsForManualMatch.match));
+    const pagination$ = searchActions$.pipe(filter((action) => action.payload.pageToken != null));
+    /**
+     * No API for empty or 1-char queries; immediate merge so switchMap cancels any in-flight HTTP.
+     */
+    const newSearchTooShortOrClear$ = searchActions$.pipe(filter((action) => action.payload.pageToken == null &&
+        action.payload.query.trim().length < 2));
+    const newSearchDebounced$ = searchActions$.pipe(filter((action) => action.payload.pageToken == null &&
+        action.payload.query.trim().length >= 2), debounceTime(300));
+    return merge(pagination$, newSearchTooShortOrClear$, newSearchDebounced$).pipe(switchMap((action) => {
+        const { query, pageToken } = action.payload;
+        if (pageToken == null && query.trim().length < 2) {
+            return EMPTY;
+        }
+        const state = state$.value;
+        const { expenseAutomationMissingReceiptsViewState: { bulkUpload: { manualSearch, sortKey, sortOrder }, }, } = state;
+        const { end, start } = rollingCalendarDateRangeInclusive(MANUAL_SEARCH_TRANSACTION_DATE_RANGE_DAYS);
+        const queryParam = {
+            start_date: start,
+            end_date: end,
+            auto_categorized: MANUAL_TRANSACTION_SEARCH_AUTO_CATEGORIZED,
+            sort_by: toTransactionsSortKey(sortKey),
+            sort_order: sortOrder === 'ascending' ? 'asc' : 'desc',
+            page_token: pageToken ?? null,
+            page_size: manualSearch.pageSize,
+            search_text: query,
+        };
+        return zeniAPI
+            .getJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/expense-automation/transactions?query=${encodeURIComponent(JSON.stringify(queryParam))}`)
+            .pipe(mergeMap((response) => {
+            if (isSuccessResponse(response) && response.data != null) {
+                const { transactions, next_page_token, total_count } = response.data;
+                const append = pageToken != null;
+                const results = transactions.map(supportedTransactionPayloadToManualSearchResult);
+                const actionsOut = [
+                    updateTransactions(transactions, (value) => value.transaction_id, 'merge'),
+                    searchTransactionsForManualMatchSuccess({
+                        append,
+                        nextPageToken: next_page_token ?? null,
+                        results,
+                        totalCount: total_count,
+                    }),
+                ];
+                return from(actionsOut);
+            }
+            return of(searchTransactionsForManualMatchFailure({
+                error: response.status,
+            }));
+        }), catchError((error) => of(searchTransactionsForManualMatchFailure({
+            error: createZeniAPIStatus('Unexpected Error', 'Search transactions for manual match errored: ' +
+                JSON.stringify(error)),
+        }))));
+    }));
+};

package/lib/esm/view/expenseAutomationView/epics/missingReceipts/uploadMissingReceiptSuccessEpic.js

@@ -12,11 +12,13 @@ export const uploadMissingReceiptSuccessEpic = (actions$, state$) => actions$.pi
     updateActions.push(updateTransaction(transactionPayload.transaction_id, transactionPayload, updateType));
     if (currentTenant != null) {
         const monthEndChecksPeriod = selectedPeriodByTenantId[currentTenant.tenantId];
-        updateActions.push(fetchMonthEndCloseChecks({
-            tenantId: currentTenant.tenantId,
-            period: monthEndChecksPeriod,
-            refreshViewInBackground: true,
-        }));
+        if (monthEndChecksPeriod != null) {
+            updateActions.push(fetchMonthEndCloseChecks({
+                tenantId: currentTenant.tenantId,
+                period: monthEndChecksPeriod,
+                refreshViewInBackground: true,
+            }));
+        }
     }
     return from(updateActions);
 }));

package/lib/esm/view/expenseAutomationView/epics/missingReceipts/watchBulkUploadBatchStatusEpic.js

@@ -0,0 +1,86 @@
+import { EMPTY, from, merge, of, timer } from 'rxjs';
+import { catchError, debounceTime, filter, mergeMap, switchMap, takeUntil, } from 'rxjs/operators';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+import { updateTransactions } from '../../../../entity/transaction/transactionReducer';
+import { isSuccessResponse } from '../../../../responsePayload';
+import { BULK_UPLOAD_AUTOMATCHING_TIMEOUT_MS } from '../../helpers/bulkUploadTiming';
+import { extractTransactionPayloadsFromBatchFiles, isBatchDetailsApiStatusCompleted, toBatchDetails, } from '../../payload/missingReceiptsPayload';
+import { bulkUploadAutomatchingTimedOut, bulkUploadReceiptsSuccess, clearBulkUpload, fetchBulkUploadBatchDetailsSuccess, fetchBulkUploadBatches, pusherBatchStatusUpdate, requestMissingReceiptsTabNavigation, restoreBulkUploadMatchingState, } from '../../reducers/missingReceiptsViewReducer';
+/** First poll after upload; then interval while batch not resolved via Pusher or API. */
+const FALLBACK_FIRST_DELAY_MS = 30000;
+/** Shorter first poll for restored sessions — batch may already be near completion. */
+const RESTORE_FIRST_DELAY_MS = 5000;
+const FALLBACK_POLL_INTERVAL_MS = 10000;
+/**
+ * On Pusher batch completion: refresh batch list (then fetchMultipleBatchDetailsEpic runs),
+ * and request switching to the Unmatched tab. Debounced to reduce duplicate refreshes.
+ */
+export const pusherBatchStatusCompletionEpic = (actions$) => actions$.pipe(filter(pusherBatchStatusUpdate.match), filter((action) => action.payload.status === 'completed'), debounceTime(300), mergeMap(() => from([
+    fetchBulkUploadBatches({
+        cacheOverride: true,
+        invalidateBatchDetailsCache: true,
+    }),
+    requestMissingReceiptsTabNavigation({ tab: 'unmatched' }),
+])));
+/**
+ * If Pusher and batch-details are delayed beyond {@link BULK_UPLOAD_AUTOMATCHING_TIMEOUT_MS},
+ * force `phase` to `completed` (dismiss automatching banner) and refresh the batch list.
+ * Cancels when the batch completes normally, bulk state is cleared, or another upload supersedes.
+ */
+export const bulkUploadAutomatchingTimeoutEpic = (actions$, state$) => actions$.pipe(filter((action) => bulkUploadReceiptsSuccess.match(action) ||
+    restoreBulkUploadMatchingState.match(action)), mergeMap((action) => {
+    const { batchId } = action.payload;
+    return timer(BULK_UPLOAD_AUTOMATCHING_TIMEOUT_MS).pipe(mergeMap(() => {
+        const bulk = state$.value.expenseAutomationMissingReceiptsViewState.bulkUpload;
+        if (bulk.phase !== 'matching' || bulk.currentBatchId !== batchId) {
+            return EMPTY;
+        }
+        return from([
+            bulkUploadAutomatchingTimedOut(batchId),
+            fetchBulkUploadBatches({ cacheOverride: true }),
+        ]);
+    }), takeUntil(merge(actions$.pipe(filter(clearBulkUpload.match)), actions$.pipe(filter(pusherBatchStatusUpdate.match), filter((a) => a.payload.batchId === batchId &&
+        a.payload.status === 'completed')), actions$.pipe(filter(fetchBulkUploadBatchDetailsSuccess.match), filter((a) => a.payload.batchId === batchId)))));
+}));
+/**
+ * Fallback polling when Pusher is slow or unavailable. Network errors on a poll tick show one
+ * error snackbar per upload session (first failure only) so the user is not spammed every
+ * interval; Pusher or a later successful poll still completes the flow.
+ */
+export const pollBulkUploadBatchStatusEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter((action) => bulkUploadReceiptsSuccess.match(action) ||
+    restoreBulkUploadMatchingState.match(action)), mergeMap((action) => {
+    const { batchId } = action.payload;
+    let pollErrorNotified = false;
+    const firstDelay = restoreBulkUploadMatchingState.match(action)
+        ? RESTORE_FIRST_DELAY_MS
+        : FALLBACK_FIRST_DELAY_MS;
+    return timer(firstDelay, FALLBACK_POLL_INTERVAL_MS).pipe(takeUntil(merge(actions$.pipe(filter(clearBulkUpload.match)), actions$.pipe(filter(pusherBatchStatusUpdate.match), filter((action) => action.payload.batchId === batchId)), actions$.pipe(filter(fetchBulkUploadBatchDetailsSuccess.match), filter((action) => action.payload.batchId === batchId)), actions$.pipe(filter(bulkUploadAutomatchingTimedOut.match), filter((action) => action.payload.batchId === batchId)))), switchMap(() => zeniAPI
+        .getJSON(`${zeniAPI.apiEndPoints.communicationAgentMicroServiceBaseUrl}/1.0/batches/${batchId}`)
+        .pipe(mergeMap((response) => {
+        /** Same batch-details URL; polls until `status` is completed (Pusher may win first). */
+        if (isSuccessResponse(response) && response.data != null) {
+            if (isBatchDetailsApiStatusCompleted(response.data.status)) {
+                const actions = [];
+                const transactionPayloads = extractTransactionPayloadsFromBatchFiles(response.data.files);
+                if (transactionPayloads.length > 0) {
+                    actions.push(updateTransactions(transactionPayloads, (value) => value.transaction_id));
+                }
+                actions.push(fetchBulkUploadBatchDetailsSuccess(toBatchDetails(response.data, zeniAPI.apiEndPoints.fileMicroServiceBaseUrl)));
+                actions.push(fetchBulkUploadBatches({ cacheOverride: true }));
+                actions.push(requestMissingReceiptsTabNavigation({ tab: 'unmatched' }));
+                return from(actions);
+            }
+        }
+        return EMPTY;
+    }), catchError(() => {
+        if (!pollErrorNotified) {
+            pollErrorNotified = true;
+            return of(openSnackbar({
+                messageSection: 'receipts_upload',
+                messageText: 'failed',
+                type: 'error',
+            }));
+        }
+        return EMPTY;
+    }))));
+}));

package/lib/esm/view/expenseAutomationView/epics/transactionCategorization/uploadTransactionReceiptSuccessEpic.js

@@ -0,0 +1,24 @@
+import { from } from 'rxjs';
+import { filter, mergeMap } from 'rxjs/operators';
+import { getCurrentTenant } from '../../../../entity/tenant/tenantSelector';
+import { updateTransaction } from '../../../../entity/transaction/transactionReducer';
+import { fetchMonthEndCloseChecks } from '../../../monthEndCloseChecksView/monthEndCloseChecksViewReducer';
+import { uploadTransactionCategorizationReceiptSuccess } from '../../reducers/transactionsViewReducer';
+export const uploadTransactionReceiptSuccessEpic = (actions$, state$) => actions$.pipe(filter(uploadTransactionCategorizationReceiptSuccess.match), mergeMap((action) => {
+    const { transactionPayload, updateType } = action.payload;
+    const updateActions = [];
+    const currentTenant = getCurrentTenant(state$.value);
+    const selectedPeriodByTenantId = state$.value.expenseAutomationViewState.selectedPeriodByTenantId;
+    updateActions.push(updateTransaction(transactionPayload.transaction_id, transactionPayload, updateType));
+    if (currentTenant != null) {
+        const monthEndChecksPeriod = selectedPeriodByTenantId[currentTenant.tenantId];
+        if (monthEndChecksPeriod != null) {
+            updateActions.push(fetchMonthEndCloseChecks({
+                tenantId: currentTenant.tenantId,
+                period: monthEndChecksPeriod,
+                refreshViewInBackground: true,
+            }));
+        }
+    }
+    return from(updateActions);
+}));

package/lib/esm/view/expenseAutomationView/helpers/bulkUploadTiming.js

@@ -0,0 +1,16 @@
+/**
+ * After upload API success, hold the bar at 100% this long before transitioning to matching,
+ * so the fill animation can complete without an abrupt swap to the auto-matching banner.
+ */
+export const BULK_UPLOAD_BAR_COMPLETE_HOLD_MS = 400;
+/**
+ * Max wall-clock wait for Pusher + batch-details resolution after upload. If exceeded, we stop
+ * fallback polling, clear the automatching banner (`phase` → completed), and refresh batch list.
+ */
+export const BULK_UPLOAD_AUTOMATCHING_TIMEOUT_MS = 300000;
+/**
+ * Rolling window (in days) for the bulk-upload batch list API. Period-agnostic — the batch list
+ * ignores the accounting month picker. Shared between the regular batch-list fetch and the
+ * restore-on-mount hydration so both flows always query the same window.
+ */
+export const BULK_UPLOAD_BATCH_LIST_DATE_RANGE_DAYS = 30;

package/lib/esm/view/expenseAutomationView/helpers/rollingCalendarDateRangeInclusive.js

@@ -0,0 +1,13 @@
+import { DEFAULT_DATE_FORMAT } from '../../../commonStateTypes/fiscalYearHelpers/formatZeniDateFY';
+import { dateNow } from '../../../zeniDayJS';
+/**
+ * Local calendar dates from (end − (days − 1)) through end, inclusive.
+ */
+export function rollingCalendarDateRangeInclusive(days) {
+    const end = dateNow().startOf('day');
+    const start = end.subtract(days - 1, 'day');
+    return {
+        end: end.format(DEFAULT_DATE_FORMAT),
+        start: start.format(DEFAULT_DATE_FORMAT),
+    };
+}

package/lib/esm/view/expenseAutomationView/payload/missingReceiptsPayload.js

@@ -1 +1,198 @@
-export {};
+import { toURL } from '../../../commonPayloadTypes/urlPayload';
+import { toAmount } from '../../../commonStateTypes/amount';
+import { getTransactionPayloadAmount, } from '../../../entity/transaction/payloadTypes/transactionPayload';
+import { toBatchFileStatus, toBatchStatusValue, toMatchSource, } from '../types/missingReceiptsViewState';
+// -- Converter functions --
+/**
+ * Maps batch-details API `files[].status` strings to canonical {@link BatchFileStatus}.
+ * Legacy aliases are supported during rollout; unknown strings map to `failed` so Redux never
+ * holds untyped status values.
+ */
+export function parseBatchFileStatus(raw) {
+    const normalizedStatus = raw.trim().toLowerCase().replace(/-/g, '_');
+    switch (normalizedStatus) {
+        case 'exact_match':
+        case 'matched':
+            return 'exact_match';
+        case 'possible_matches':
+        case 'possible_match':
+        case 'possiblematch':
+        case 'un_matched':
+        case 'unmatched':
+            return 'possible_matches';
+        case 'no_match':
+        case 'nomatch':
+            return 'no_match';
+        case 'failed':
+            return 'failed';
+        default:
+            return 'failed';
+    }
+}
+export function toBatchFile(payload, filesEndPoint) {
+    return {
+        attachmentId: payload.attachment_id,
+        candidates: payload.candidates?.map((candidate) => ({
+            transactionId: candidate.transaction_id,
+            matchScore: candidate.match_score,
+        })),
+        fileDownloadUrl: payload.file_id != null && filesEndPoint != null
+            ? `${filesEndPoint}/1.0/files/${payload.file_id}?query=${encodeURIComponent(JSON.stringify({ download_file: true }))}`
+            : null,
+        fileId: payload.file_id,
+        filePreviewUrl: payload.file_preview_url,
+        filename: payload.filename,
+        matchSource: payload.match_source != null
+            ? toMatchSource(payload.match_source)
+            : undefined,
+        matchedTransactionId: payload.matched_transaction?.transaction_id,
+        status: toBatchFileStatus(payload.status),
+    };
+}
+export function extractTransactionPayloadsFromBatchFiles(files) {
+    const seen = new Set();
+    const payloads = [];
+    for (const file of files) {
+        if (file.matched_transaction != null) {
+            const id = file.matched_transaction.transaction_id;
+            if (!seen.has(id)) {
+                seen.add(id);
+                payloads.push(matchedTransactionPayloadToSupportedTransactionPayload(file.matched_transaction));
+            }
+        }
+        if (file.candidates != null) {
+            for (const candidate of file.candidates) {
+                const id = candidate.transaction_id;
+                if (!seen.has(id)) {
+                    seen.add(id);
+                    payloads.push(matchedTransactionPayloadToSupportedTransactionPayload(candidate));
+                }
+            }
+        }
+    }
+    return payloads;
+}
+function matchedTransactionPayloadToSupportedTransactionPayload(payload) {
+    return {
+        transaction_id: payload.transaction_id,
+        transaction_type: payload.transaction_type ?? 'expense',
+        transaction_date: payload.transaction_date ?? '',
+        currency_code: payload.currency_code,
+        total_amount: payload.amount,
+        vendor_name: payload.vendor_name,
+        logo: payload.vendor_logo == null ? undefined : toURL(payload.vendor_logo),
+    };
+}
+export function toBatchSummary(payload) {
+    return {
+        failed: payload.failed,
+        matched: payload.matched,
+        noMatch: payload.no_match,
+        possibleMatches: payload.possible_matches,
+        total: payload.total,
+    };
+}
+export function toBatchDetails(payload, filesEndPoint) {
+    return {
+        batchId: payload.batch_id,
+        createdAt: payload.created_at,
+        files: payload.files.map((file) => toBatchFile(file, filesEndPoint)),
+        status: toBatchStatusValue(payload.status),
+        summary: toBatchSummary(payload.summary),
+        ...(payload.user_id != null && payload.user_id !== ''
+            ? { userId: payload.user_id }
+            : {}),
+    };
+}
+/** Batch is still in-flight for automatching (GET /batches/:id while not completed). */
+export function isBatchDetailsStatusPendingOrProcessing(status) {
+    const s = status.toLowerCase();
+    return s === 'processing' || s === 'pending';
+}
+/** Batch list `status` is a string from the API — compare case-insensitively. */
+export function isBatchListStatusCompleted(status) {
+    return status.toLowerCase() === 'completed';
+}
+/**
+ * Subset of the get-all-batches (`/batches?query=...`) list that is eligible for
+ * `GET /batches/:batchId` details fetches. The stored list may include pending, failed, or other
+ * statuses for UI; only `completed` rows should trigger batch-details requests.
+ */
+export function filterBatchListItemsForBatchDetailsFetch(batches) {
+    return batches.filter((batch) => isBatchListStatusCompleted(batch.status));
+}
+/**
+ * Batch details API response `status` field — only completed payloads should be stored from
+ * multi-batch fetch paths (list can be briefly stale vs. live processing state).
+ */
+export function isBatchDetailsApiStatusCompleted(status) {
+    return status.toLowerCase() === 'completed';
+}
+export function findBatchListItemForBatchId(batchListByPeriod, batchId) {
+    for (const list of Object.values(batchListByPeriod)) {
+        const found = list.find((batch) => batch.batchId === batchId);
+        if (found != null) {
+            return found;
+        }
+    }
+    return undefined;
+}
+/**
+ * Whether it is appropriate to call `GET .../batches/:id` for details.
+ * Skips when live batch status or batch list row indicates the batch is not completed yet.
+ * When status is unknown in both sources, allows the request (e.g. dispatch before list refresh).
+ */
+export function shouldFetchBatchDetailsForBatchId(batchStatusById, batchListByPeriod, batchId) {
+    const live = batchStatusById[batchId]?.status;
+    if (live === 'completed') {
+        return true;
+    }
+    if (live === 'pending' || live === 'processing') {
+        return false;
+    }
+    const listItem = findBatchListItemForBatchId(batchListByPeriod, batchId);
+    if (listItem != null && !isBatchListStatusCompleted(listItem.status)) {
+        return false;
+    }
+    return true;
+}
+export function toBatchListItem(payload) {
+    return {
+        batchId: payload.batch_id,
+        createdAt: payload.created_at,
+        failedCount: payload.failed_count,
+        matchedCount: payload.matched_count,
+        noMatchCount: payload.no_match_count,
+        possibleMatchesCount: payload.possible_matches_count,
+        status: payload.status,
+        totalFiles: payload.total_files,
+        userId: payload.user_id,
+    };
+}
+/**
+ * Amount shown in the Unmatched tab manual-search list: **first line only** when `lines` exist.
+ * Falls back to transaction-level totals via {@link getTransactionPayloadAmount} when there is
+ * no line or no line amount (same currency fields as the rest of the transaction payload).
+ */
+function getManualSearchListAmountFromPayload(payload) {
+    const lineAmount = payload.lines?.[0]?.amount;
+    if (lineAmount != null) {
+        return toAmount(lineAmount, payload.currency_code, payload.currency_symbol);
+    }
+    return getTransactionPayloadAmount(payload);
+}
+/** Maps expense-automation transaction rows to manual-search list rows (Unmatched tab). */
+export function supportedTransactionPayloadToManualSearchResult(payload) {
+    const amountPayload = getManualSearchListAmountFromPayload(payload);
+    return {
+        amount: amountPayload.amount,
+        currencyCode: amountPayload.currencyCode,
+        entityId: payload.vendor_id ?? payload.customer_id ?? '',
+        memo: payload.transaction_memo ?? '',
+        transactionDate: payload.transaction_date,
+        transactionId: payload.transaction_id,
+        transactionType: payload.transaction_type,
+        vendorName: payload.vendor_name ?? '',
+        vendorLogo: toURL(payload.logo)?.href,
+    };
+}