@zeniai/client-epic-state 5.0.55-betaSS2 → 5.0.55-betaVR1

package/lib/esm/index.js

@@ -167,13 +167,12 @@ import { clearExpenseAutomationFluxAnalysisView, fetchFluxAnalysisView, reviewFl
 import { clearJeScheduleLocalData as clearExpenseAutomationJEScheduleLocalData, clearExpenseAutomationJESchedulesView, fetchJeSchedulesPage as fetchExpenseAutomationJESchedulesPage, ignoreRecommendedJeSchedule as ignoreExpenseAutomationJESchedule, initializeAccountSettingsView as initializeJeAccountSettingsView, initializeJeScheduleLocalData, removeJeScheduleTransactionKey, retryJeSchedule as retryExpenseAutomationJESchedule, saveAccountSettings as saveJeAccountSettings, saveAccountSettingsLocalData as saveJeAccountSettingsLocalData, updateJESchedulesUIState as updateExpenseAutomationJESchedulesUIState, updateJeScheduleLocalDataById, updateJeScheduleTransactionKeys, } from './view/expenseAutomationView/reducers/jeSchedulesViewReducer';
 import { acknowledgeBulkUploadConfirmMatchComplete, bulkUploadAutomatchingTimedOut, bulkUploadReceipts, bulkUploadReceiptsFailure, bulkUploadReceiptsSuccess, clearBulkUpload, clearManualSearchResults, clearMissingReceiptsTabNavigation, confirmBulkUploadMatch, confirmBulkUploadMatchFailure, confirmBulkUploadMatchSuccess, fetchBulkUploadBatchDetails, fetchBulkUploadBatchDetailsFailure, fetchBulkUploadBatchDetailsSuccess, fetchBulkUploadBatches, fetchBulkUploadBatchesFailure, fetchBulkUploadBatchesSuccess, fetchCompletedTransactions, fetchCompletedTransactionsFailure, fetchCompletedTransactionsSuccess, fetchMissingReceipts as fetchExpenseAutomationMissingReceipts, fetchMoreBatchDetails, fetchMoreBatchDetailsComplete, fetchMoreBatchDetailsFailure, markMissingReceiptAsDone as markExpenseAutomationMissingReceiptAsDone, pusherBatchStatusUpdate, requestMissingReceiptsTabNavigation, restoreBulkUploadAutomatchingOnMount, restoreBulkUploadMatchingState, searchTransactionsForManualMatch, searchTransactionsForManualMatchFailure, searchTransactionsForManualMatchSuccess, setBulkUploadCompletedSubTab, setBulkUploadResultsTab, setBulkUploadSortConfig, setBulkUploadUploadedFileCount, storeBatchDetails, updateBulkUploadProgress, updateMissingReceiptUploadState as updateExpenseAutomationMissingReceiptUploadState, updateMissingReceiptsUIState as updateExpenseAutomationMissingReceiptsUIState, uploadMissingReceiptSuccess as uploadExpenseAutomationMissingReceiptSuccess, } from './view/expenseAutomationView/reducers/missingReceiptsViewReducer';
 import { deleteAccountStatement, excludeAccountFromReconciliation, fetchReconciliation as fetchReconciliationView, includeAccountInReconciliation, saveReconciliationDetail as saveExpenseAutomationReconciliationDetail, saveReconciliationReview as saveExpenseAutomationReconciliationReview, setConnectionInProgressForAccount as setConnectionInProgressForAccountReconciliation, setStatementParseInProgress, updateAccountReconciliationLocalData as updateExpenseAutomationAccountReconciliationLocalData, updateSelectedAccountId as updateExpenseAutomationAccountReconciliationSelectedAccountId, updateSelectedTab as updateExpenseAutomationAccountReconciliationSelectedTab, updateReconListScrollPosition as updateExpenseAutomationReconListScrollPosition, updateReviewTabSortState as updateExpenseAutomationReconReviewTabListSortState, updateReviewTabLocalData as updateExpenseAutomationReconReviewTabLocalData, updateReconcileTabListScrollState as updateExpenseAutomationReconcileTabListScrollState, updateReconcileTabListSortState as updateExpenseAutomationReconcileTabListSortState, updateReconcileTabLocalData as updateExpenseAutomationReconcileTabLocalData, updateSelectedDrawerAccountId as updateExpenseAutomationSelectedDrawerAccountId, updateNodeCollapseState, updateStatementUploadChosen, uploadAccountStatement, } from './view/expenseAutomationView/reducers/reconciliationViewReducer';
-import { backgroundRefetchReviewTab, clearExpenseAutomationTransactionsView, fetchTransactionCategorization, fetchTransactionCategorizationFailure, fetchTransactionCategorizationView, initializeTransactionCategorizationViewLocalData, markTransactionAsNotMiscategorized, saveTransactionCategorization, saveTransactionCategorizationLocalData, setAllItemsToCategoryClassInLocalDataForCategorization, setEntityRecommendationForLineIdsForCategorization, syncTransactionCategorizationFromDetailSave, updateCurrentSelectedTransactionCategorizationTab, updateTransactionCategorizationCompletedSubTab, updateSelectedCheckboxTransactionIds, updateSelectedCustomerForTransaction, updateSelectedTransactionId, updateSelectedVendorForTransaction, updateTransactionCategorization, updateTransactionCategorizationSaveStatus, updateTransactionCategorizationUIState, updateTransactionCategorizationUploadReceiptState, uploadTransactionCategorizationReceiptSuccess, } from './view/expenseAutomationView/reducers/transactionsViewReducer';
+import { backgroundRefetchReviewTab, clearExpenseAutomationTransactionsView, fetchTransactionCategorization, fetchTransactionCategorizationFailure, fetchTransactionCategorizationView, initializeTransactionCategorizationViewLocalData, markTransactionAsNotMiscategorized, saveTransactionCategorization, saveTransactionCategorizationLocalData, setAllItemsToCategoryClassInLocalDataForCategorization, setEntityRecommendationForLineIdsForCategorization, syncTransactionCategorizationFromDetailSave, updateCurrentSelectedTransactionCategorizationTab, updateSelectedCheckboxTransactionIds, updateSelectedCustomerForTransaction, updateSelectedTransactionId, updateSelectedVendorForTransaction, updateTransactionCategorization, updateTransactionCategorizationSaveStatus, updateTransactionCategorizationUIState, updateTransactionCategorizationUploadReceiptState, uploadTransactionCategorizationReceiptSuccess, } from './view/expenseAutomationView/reducers/transactionsViewReducer';
 import { getExpenseAutomationFluxAnalysisView } from './view/expenseAutomationView/selectors/fluxAnalysisViewSelector';
 import { getExpenseAutomationReconciliationView, isAccountReconReport, } from './view/expenseAutomationView/selectors/reconciliationViewSelector';
 import { getExpenseAutomationTransactionView } from './view/expenseAutomationView/selectors/transactionCategorizationSelector';
 import { toJEScheduleMainTab as toExpenseAutomationJEScheduleMainTab, toJEScheduleSortKey as toExpenseAutomationJEScheduleSortKey, } from './view/expenseAutomationView/types/jeSchedulesViewState';
-import { BATCH_FILE_STATUSES, isUnmatchedTabFileStatus, toBatchFileStatus, toBatchStatusValue, toBulkUploadPhase, toBulkUploadResultsTab, toBulkUploadSortKey, toMatchSource, toMissingReceiptsTab, } from './view/expenseAutomationView/types/missingReceiptsViewState';
-import { toCompletedSubTab, } from './view/expenseAutomationView/types/completedSubTab';
+import { BATCH_FILE_STATUSES, isUnmatchedTabFileStatus, toBatchFileStatus, toBatchStatusValue, toBulkUploadPhase, toBulkUploadResultsTab, toBulkUploadSortKey, toCompletedSubTab, toMatchSource, toMissingReceiptsTab, } from './view/expenseAutomationView/types/missingReceiptsViewState';
 import { toMissingReceiptsSortKey as toExpenseAutomationMissingReceiptsSortKey, } from './view/expenseAutomationView/types/missingReceiptsViewState';
 import { toReconciliationTabsType, } from './view/expenseAutomationView/types/reconciliationViewState';
 import { toTransactionsTabKey as toExpenseAutomationTransactionsTabKey, toTransactionsSortKey, } from './view/expenseAutomationView/types/transactionsViewState';
@@ -379,6 +378,7 @@ import { getAllTopExpenses, getTop6Expenses, getTopExpenses, } from './view/topE
 import { TOP_EX_TIME_PERIODS, } from './view/topEx/topExState';
 import { getAccountingProviderAttachment, } from './view/transactionDetail/getAccountingProviderAttachmentSelector';
 import { getChangedLineItemCountFromLocalData, isAccountUncategorized, } from './view/transactionDetail/transactionDetailLocalDataHelper';
+import { JOURNAL_ENTRY_SORT_KEYS, filterJournalEntryLinesExcludingLinked, journalEntryDefaultSortConfig, journalEntryTotalsByPostingSide, sortJournalEntryLines, sumJournalEntryAmounts, toJournalEntrySortKey, } from './view/transactionDetail/journalEntryLinesViewModel';
 import { clearTransactionDetailSaveStatus, deleteTransactionAttachment, downloadAccountingProviderAttachment, downloadAccountingProviderAttachmentFailure, downloadAccountingProviderAttachmentSuccess, fetchTransactionDetail, initializeTransactionDetailLocalData, removeEntityRecommendationForLineIdForTransactionDetail, resetAllLineItemsToVendor, resetLineItemsCategoryClassInLocalData, resetSelectedCustomer, resetVendor, saveTransactionDetail, saveTransactionDetailLocalData, setAllLineItemsLocalDataIsUpdateAllChecked, setAllLineItemsToCategoryClassInLocalData, setIsVendorUpdateAllChecked, updateLatestSelectedEntity, updateLocalDataWithTransactionsUpdateWithVendorCheckbox, updateSelectedCustomer, updateSelectedVendor, updateTransactionDetail, updateVendorBulkRecommendationsFetchStatus, updateVendorToAllLineItems, uploadMissingAttachmentSuccess, } from './view/transactionDetail/transactionDetailReducer';
 import { getInitialUpdatablePeriodsForTransactionRecommendations, getTransactionDetail, getTransactionDetailForTransaction, } from './view/transactionDetail/transactionDetailSelector';
 import { getThirdPartyIdFromTransactionId, } from './view/transactionDetail/transactionDetailState';
@@ -442,7 +442,7 @@ export { stringToUnion, stringToUnionStrict };
 export { fetchMonthEndCloseChecks, fetchMonthClosePerformanceTrend, getMonthEndCloseChecksViewByTenantId, ALL_MONTH_END_CLOSE_CHECKS_FREQUENCY, };
 export { 
 // Bulk Upload Types
-BATCH_FILE_STATUSES, isUnmatchedTabFileStatus, toBatchFileStatus, toBatchStatusValue, toBulkUploadPhase, toBulkUploadResultsTab, toBulkUploadSortKey, toCompletedSubTab, toMatchSource, toMissingReceiptsTab, toExpenseAutomationJEScheduleMainTab, toExpenseAutomationJEScheduleSortKey, getExpenseAutomationView, toExpenseAutomationMissingReceiptsSortKey, toExpenseAutomationTransactionsTabKey, toExpenseAutomationViewType, uploadExpenseAutomationMissingReceiptSuccess, markExpenseAutomationMissingReceiptAsDone, fetchAllExpenseAutomationTabs, refreshExpenseAutomationCurrentTab, updateCurrentSelectedTransactionCategorizationTab, updateTransactionCategorizationCompletedSubTab, fetchExpenseAutomationMissingReceipts, 
+BATCH_FILE_STATUSES, isUnmatchedTabFileStatus, toBatchFileStatus, toBatchStatusValue, toBulkUploadPhase, toBulkUploadResultsTab, toBulkUploadSortKey, toCompletedSubTab, toMatchSource, toMissingReceiptsTab, toExpenseAutomationJEScheduleMainTab, toExpenseAutomationJEScheduleSortKey, getExpenseAutomationView, toExpenseAutomationMissingReceiptsSortKey, toExpenseAutomationTransactionsTabKey, toExpenseAutomationViewType, uploadExpenseAutomationMissingReceiptSuccess, markExpenseAutomationMissingReceiptAsDone, fetchAllExpenseAutomationTabs, refreshExpenseAutomationCurrentTab, updateCurrentSelectedTransactionCategorizationTab, fetchExpenseAutomationMissingReceipts, 
 // Bulk Upload Actions
 bulkUploadReceipts, bulkUploadAutomatchingTimedOut, bulkUploadReceiptsSuccess, bulkUploadReceiptsFailure, restoreBulkUploadAutomatchingOnMount, restoreBulkUploadMatchingState, updateBulkUploadProgress, pusherBatchStatusUpdate, requestMissingReceiptsTabNavigation, clearMissingReceiptsTabNavigation, fetchBulkUploadBatchDetails, fetchBulkUploadBatchDetailsSuccess, fetchBulkUploadBatchDetailsFailure, storeBatchDetails, fetchMoreBatchDetails, fetchMoreBatchDetailsComplete, fetchMoreBatchDetailsFailure, fetchBulkUploadBatches, fetchBulkUploadBatchesSuccess, fetchBulkUploadBatchesFailure, confirmBulkUploadMatch, confirmBulkUploadMatchSuccess, confirmBulkUploadMatchFailure, setBulkUploadResultsTab, setBulkUploadCompletedSubTab, setBulkUploadSortConfig, setBulkUploadUploadedFileCount, clearBulkUpload, searchTransactionsForManualMatch, searchTransactionsForManualMatchSuccess, searchTransactionsForManualMatchFailure, clearManualSearchResults, acknowledgeBulkUploadConfirmMatchComplete, fetchCompletedTransactions, fetchCompletedTransactionsSuccess, fetchCompletedTransactionsFailure, fetchFluxAnalysisView, clearExpenseAutomationFluxAnalysisView, updateOperatingExpensesIdsForReview as updateFluxOperatingExpensesIdsForReview, updateSelectedSectionIdsForReview as updateFluxAnalysisSelectedSectionIdsForReview, reviewFluxAnalysisView, updateExpenseAutomationMissingReceiptUploadState, updateExpenseAutomationMissingReceiptsUIState, updateTransactionCategorizationUploadReceiptState, uploadTransactionCategorizationReceiptSuccess, getExpenseAutomationFluxAnalysisView, updateCurrentSelectedView, updateCurrentSelectedPeriod, getExpenseAutomationTransactionView, updateFluxAnalysisViewUIState, updateFluxAnalysisViewPageMetaData, MAX_SELECTION_LIMIT, checkIfAllLineItemsAreCategoryClassFilled, getLineItemsByTransactionIdsFromLocalData, isAnyItemWithUncategorizedExpenseAccount, excludeAccountFromReconciliation, includeAccountInReconciliation, saveExpenseAutomationReconciliationDetail, updateExpenseAutomationReconcileTabListScrollState, updateExpenseAutomationReconReviewTabListSortState, updateExpenseAutomationReconcileTabListSortState, updateExpenseAutomationReconcileTabLocalData, updateExpenseAutomationAccountReconciliationSelectedTab, updateExpenseAutomationAccountReconciliationSelectedAccountId, getExpenseAutomationReconciliationView, fetchReconciliationView, uploadAccountStatementIntoDocumentAI, updateExpenseAutomationReconListScrollPosition, setConnectionInProgressForAccountReconciliation, getAccountReconByAccountIdAndSelectedPeriod, toReconciliationTabsType, isAccountReconReport, updateExpenseAutomationReconReviewTabLocalData, updateExpenseAutomationSelectedDrawerAccountId, saveExpenseAutomationReconciliationReview, updateExpenseAutomationAccountReconciliationLocalData, toReconciliationAccountSource, deleteAccountStatement, uploadAccountStatement, updateNodeCollapseState, updateStatementUploadChosen, isReviewTransactionBankTransferType, isReviewTransactionBillPaymentType, isReviewTransactionCreditCardPaymentType, isReviewTransactionDepositType, isReviewTransactionExpenseType, isReviewTransactionCreditCardCreditType, setStatementParseInProgress, };
 export { fetchTransactionCategorization, fetchTransactionCategorizationView, updateTransactionCategorizationUIState, updateSelectedCheckboxTransactionIds, setEntityRecommendationForLineIdsForCategorization, initializeTransactionCategorizationViewLocalData, setAllItemsToCategoryClassInLocalDataForCategorization, saveTransactionCategorizationLocalData, fetchTransactionCategorizationFailure, saveTransactionCategorization, updateTransactionCategorization, updateTransactionCategorizationSaveStatus, markTransactionAsNotMiscategorized, updateSelectedVendorForTransaction, updateSelectedCustomerForTransaction, updateSelectedTransactionId, syncTransactionCategorizationFromDetailSave, backgroundRefetchReviewTab, clearExpenseAutomationTransactionsView, toTransactionsSortKey, };
@@ -573,6 +573,7 @@ export { getNextNthWorkingDay, getPreviousNthWorkingDay, isHolidayToday, filterD
 export { fetchCompanyOnboardingView, fetchQBOConnectionPool, updateQBOConnectionPoolExternalConnection, fetchOnboardingCompletedCompanies, saveOnboardingCustomerCompletedStatus, toProductType, toProductTypeStrict, getOnboardingCockpitView, getNewOnboardingCustomerView, getOnboardingEmailGroup, initializeOnboardingCustomerViewUpdateData, clearOnboardingCustomerViewUpdateData, saveOnboardingCustomerViewUpdateData, updateOnboardingCustomerListUIState, updateCustomerCreationStatus, updateStatusAfterOnboardingCompleted, saveOnboardingCustomerViewUpdates, saveOnboardingCustomerNotes, saveOnboardingCustomerDataInLocalStore, updateOnboardingCustomerDataInLocalStore, resetNewOnboardedCustomerId, sendOnboardingCustomerViewInvite, retryBankAccountConnectionForOnboarding, };
 export { getTransactionsListByCategoryType, getTransactionListUIStateByCategoryType, };
 export { getChangedLineItemCountFromLocalData, isAccountUncategorized };
+export { JOURNAL_ENTRY_SORT_KEYS, filterJournalEntryLinesExcludingLinked, journalEntryDefaultSortConfig, journalEntryTotalsByPostingSide, sortJournalEntryLines, sumJournalEntryAmounts, toJournalEntrySortKey, };
 export { openSnackbar, closeSnackbar, getSnackbar, };
 export { getSpendManagementEffectiveListPeriod, getSelectedCompanyOfficer, showBillPayPromoPage, showReimbursementPromoPage, getActualPaymentDate, isVerifiedStatusCode, isVerifiedPaymentAccountProviderStatusCode, isBulkProcessing, getBillListUniqueType, getRemiListUniqueType, getBulkOperationSuffix, toAccountsPromoConfig, toSameDayAchDisablementConfig, isPaymentMethodOutsideZeni, isAwaitingMarkAsPaid, checkIfLowBalance, };
 export { canSendMonthEndEmailReport, shouldEnableCalendarPickerForLastReportSent, };

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

@@ -46,10 +46,6 @@ export const searchTransactionsForManualMatchEpic = (actions$, state$, zeniAPI)
             page_token: pageToken ?? null,
             page_size: manualSearch.pageSize,
             search_text: query,
-            // Manual search ignores the Completed sub-tab axis — always span 'all'
-            // so the receipt-matching UX returns results regardless of where the
-            // transaction would otherwise be bucketed on the Completed tab.
-            sub_tab: 'all',
         };
         return zeniAPI
             .getJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/expense-automation/transactions?query=${encodeURIComponent(JSON.stringify(queryParam))}`)

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

@@ -5,7 +5,7 @@ import { getCurrentTenant } from '../../../../entity/tenant/tenantSelector';
 import { updateTransactions } from '../../../../entity/transaction/transactionReducer';
 import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
 import { getLineItemsByTransactionsIdsFromResponse } from '../../helpers/transactionCategorizationLocalDataHelper';
-import { fetchTransactionCategorization, fetchTransactionCategorizationFailure, fetchTransactionCategorizationSuccess, initializeTransactionCategorizationViewLocalData, resetOtherTabsFetchState, updateParentTotalCountForTab, updateTotalCountForTransactionCategorization, updateTransactionCategorizationUIState, } from '../../reducers/transactionsViewReducer';
+import { fetchTransactionCategorization, fetchTransactionCategorizationFailure, fetchTransactionCategorizationSuccess, initializeTransactionCategorizationViewLocalData, resetOtherTabsFetchState, updateTotalCountForTransactionCategorization, updateTransactionCategorizationUIState, } from '../../reducers/transactionsViewReducer';
 import { TRANSACTIONS_TABS, toTransactionsSortKey, } from '../../types/transactionsViewState';
 export const fetchTransactionCategorizationEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(fetchTransactionCategorization.match), switchMap((action) => {
     const { expenseAutomationViewState: { selectedPeriodByTenantId }, expenseAutomationTransactionsViewState, } = state$.value;
@@ -23,9 +23,6 @@ export const fetchTransactionCategorizationEpic = (actions$, state$, zeniAPI) =>
         page_token: pageToken,
         page_size: 25,
         search_text: uiState.searchString,
-        sub_tab: selectedTab === 'autoCategorized'
-            ? expenseAutomationTransactionsViewState.selectedTransactionCategorizationCompletedSubTab
-            : 'all',
     };
     return zeniAPI
         .getJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/expense-automation/transactions?query=${encodeURIComponent(JSON.stringify(queryParam))}`)
@@ -48,11 +45,6 @@ export const fetchTransactionCategorizationEpic = (actions$, state$, zeniAPI) =>
                 selectedTab,
                 totalCount: response.data.total_count,
             }));
-            updateActions.push(updateParentTotalCountForTab({
-                selectedPeriod,
-                selectedTab,
-                parentTotalCount: response.data.parent_tab_total_count,
-            }));
             updateActions.push(resetOtherTabsFetchState({
                 refreshViewInBackground,
                 tabs: TRANSACTIONS_TABS.filter((tab) => selectedTab !== tab),

package/lib/esm/view/expenseAutomationView/reducers/transactionsViewReducer.js

@@ -41,44 +41,12 @@ export const initialTransactionTabViewState = {
     selectedTransactionLineId: undefined,
 };
 export const initialState = {
-    autoCategorizedSubTabCache: {},
-    parentTotalCountByTab: {
-        review: {},
-        autoCategorized: {},
-    },
     selectedTransactionCategorizationTab: 'review',
-    selectedTransactionCategorizationCompletedSubTab: 'all',
     transactionCategorizationView: {
         review: { ...initialTransactionTabViewState },
         autoCategorized: { ...initialTransactionTabViewState },
     },
 };
-/**
- * Capture the autoCategorized tab's current paginated dataset for a sub-tab.
- * The mid-flight `'In-Progress'` state is normalised to `'Completed'` because
- * the in-flight request is cancelled by `switchMap` in the fetch epic when the
- * sub-tab changes — restoring `'In-Progress'` later would leave the UI stuck
- * showing a phantom loading state with no fetch actually running. Length-zero
- * datasets degrade to `'Not-Started'` so the next visit triggers a fresh
- * fetch from page 1 instead of short-circuiting on stale empty caches.
- */
-function snapshotAutoCategorizedTab(autoCat) {
-    const transactionIdsBySelectedPeriod = {
-        ...autoCat.transactionIdsBySelectedPeriod,
-    };
-    const hasAnyLoadedRows = Object.values(transactionIdsBySelectedPeriod).some((ids) => ids.length > 0);
-    let normalisedFetchState = autoCat.fetchState;
-    if (normalisedFetchState === 'In-Progress') {
-        normalisedFetchState = hasAnyLoadedRows ? 'Completed' : 'Not-Started';
-    }
-    return {
-        error: autoCat.error,
-        fetchState: normalisedFetchState,
-        pageToken: autoCat.uiState.pageToken,
-        totalCount: { ...autoCat.uiState.totalCount },
-        transactionIdsBySelectedPeriod,
-    };
-}
 const expenseAutomationTransactionsView = createSlice({
     name: 'expenseAutomationTransactionsView',
     initialState,
@@ -292,48 +260,6 @@ const expenseAutomationTransactionsView = createSlice({
                 return { payload: { newSelectedTab } };
             },
         },
-        updateTransactionCategorizationCompletedSubTab: {
-            reducer(draft, action) {
-                const { newSubTab } = action.payload;
-                const previousSubTab = draft.selectedTransactionCategorizationCompletedSubTab;
-                if (previousSubTab === newSubTab) {
-                    return;
-                }
-                const autoCat = draft.transactionCategorizationView.autoCategorized;
-                // Snapshot the outgoing sub-tab so a future revisit can short-circuit
-                // the fetch epic (mirrors the parent-tab "don't refetch what's
-                // already cached" behaviour). Period-scoped data is preserved as-is
-                // because the snapshot itself is keyed only by sub-tab; the active
-                // tab's per-period maps remain the source of truth while live.
-                draft.autoCategorizedSubTabCache[previousSubTab] =
-                    snapshotAutoCategorizedTab(autoCat);
-                const cached = draft.autoCategorizedSubTabCache[newSubTab];
-                if (cached != null) {
-                    autoCat.uiState.pageToken = cached.pageToken;
-                    autoCat.uiState.totalCount = { ...cached.totalCount };
-                    autoCat.transactionIdsBySelectedPeriod = {
-                        ...cached.transactionIdsBySelectedPeriod,
-                    };
-                    autoCat.fetchState = cached.fetchState;
-                    autoCat.error = cached.error;
-                }
-                else {
-                    // Sub-tab has never been visited — clear the active slot so the
-                    // view-epic's `fetchState === 'Not-Started' || transactionIds.length
-                    // === 0` cache check falls through and triggers a fresh page-1
-                    // fetch for the new dataset.
-                    autoCat.uiState.pageToken = null;
-                    autoCat.uiState.totalCount = {};
-                    autoCat.transactionIdsBySelectedPeriod = {};
-                    autoCat.fetchState = 'Not-Started';
-                    autoCat.error = undefined;
-                }
-                draft.selectedTransactionCategorizationCompletedSubTab = newSubTab;
-            },
-            prepare(newSubTab) {
-                return { payload: { newSubTab } };
-            },
-        },
         updateTransactionCategorization: {
             reducer(draft, action) {
                 const selectedTab = action.payload.selectedTab;
@@ -771,10 +697,6 @@ const expenseAutomationTransactionsView = createSlice({
             const { selectedTab, selectedPeriod, totalCount } = action.payload;
             draft.transactionCategorizationView[selectedTab].uiState.totalCount[toMonthYearPeriodId(selectedPeriod)] = totalCount;
         },
-        updateParentTotalCountForTab(draft, action) {
-            const { selectedTab, selectedPeriod, parentTotalCount } = action.payload;
-            draft.parentTotalCountByTab[selectedTab][toMonthYearPeriodId(selectedPeriod)] = parentTotalCount;
-        },
         updateSelectedCheckboxTransactionIds(draft, action) {
             const selectedTab = action.payload.selectedTab;
             const transactionIds = action.payload.transactionIds;
@@ -785,7 +707,6 @@ const expenseAutomationTransactionsView = createSlice({
             draft.transactionCategorizationView[selectedTab] = {
                 ...initialTransactionTabViewState,
             };
-            draft.parentTotalCountByTab[selectedTab] = {};
         },
         clearExpenseAutomationTransactionsView(draft) {
             Object.assign(draft, initialState);
@@ -882,5 +803,5 @@ const expenseAutomationTransactionsView = createSlice({
         },
     },
 });
-export const { fetchTransactionCategorization, updateTransactionCategorizationUIState, initializeTransactionCategorizationViewLocalData, saveTransactionCategorizationLocalData, fetchTransactionCategorizationFailure, saveTransactionCategorization, updateTransactionCategorization, updateCurrentSelectedTransactionCategorizationTab, updateTransactionCategorizationCompletedSubTab, updateTransactionCategorizationSaveStatus, markTransactionAsNotMiscategorized, updateStatusForTransactionNotMiscategorizedUpdateForCategorization, updateSelectedVendorForTransaction, updateSelectedCustomerForTransaction, setAllItemsToCategoryClassInLocalDataForCategorization, updateTotalCountForTransactionCategorization, updateParentTotalCountForTab, fetchTransactionCategorizationSuccess, resetOtherTabsFetchState, fetchTransactionCategorizationView, updateSelectedCheckboxTransactionIds, clearExpenseAutomationTransactionsViewPerTabView, clearExpenseAutomationTransactionsView, setEntityRecommendationForLineIdsForCategorization, updateSelectedTransactionId, syncTransactionCategorizationFromDetailSave, backgroundRefetchReviewTab, updateTransactionCategorizationUploadReceiptState, uploadTransactionCategorizationReceiptSuccess, } = expenseAutomationTransactionsView.actions;
+export const { fetchTransactionCategorization, updateTransactionCategorizationUIState, initializeTransactionCategorizationViewLocalData, saveTransactionCategorizationLocalData, fetchTransactionCategorizationFailure, saveTransactionCategorization, updateTransactionCategorization, updateCurrentSelectedTransactionCategorizationTab, updateTransactionCategorizationSaveStatus, markTransactionAsNotMiscategorized, updateStatusForTransactionNotMiscategorizedUpdateForCategorization, updateSelectedVendorForTransaction, updateSelectedCustomerForTransaction, setAllItemsToCategoryClassInLocalDataForCategorization, updateTotalCountForTransactionCategorization, fetchTransactionCategorizationSuccess, resetOtherTabsFetchState, fetchTransactionCategorizationView, updateSelectedCheckboxTransactionIds, clearExpenseAutomationTransactionsViewPerTabView, clearExpenseAutomationTransactionsView, setEntityRecommendationForLineIdsForCategorization, updateSelectedTransactionId, syncTransactionCategorizationFromDetailSave, backgroundRefetchReviewTab, updateTransactionCategorizationUploadReceiptState, uploadTransactionCategorizationReceiptSuccess, } = expenseAutomationTransactionsView.actions;
 export default expenseAutomationTransactionsView.reducer;

package/lib/esm/view/expenseAutomationView/selectors/transactionCategorizationSelector.js

@@ -10,7 +10,7 @@ import { getProjectList } from '../../projectList/projectListSelector';
 import { getAllSteps } from '../selectorTypes/expenseAutomationViewSelectorTypes';
 export function getExpenseAutomationTransactionView(state) {
     const { accountState, classState, classListState, accountListState, expenseAutomationTransactionsViewState, expenseAutomationViewState, projectState, projectListState, transactionState, monthEndCloseChecksState, monthEndCloseChecksViewState, } = state;
-    const { selectedTransactionCategorizationCompletedSubTab, selectedTransactionCategorizationTab, } = expenseAutomationTransactionsViewState;
+    const { selectedTransactionCategorizationTab } = expenseAutomationTransactionsViewState;
     const { uiState, refreshStatus, saveStatus, markAsNotMiscategorizedStatus, transactionIdsBySelectedPeriod, transactionReviewLocalDataById, selectedCheckBoxTransactionIds, transactionIdsWithUnsavedData, uploadReceiptStatusById, selectedTransactionId, selectedTransactionLineId, } = expenseAutomationTransactionsViewState.transactionCategorizationView[selectedTransactionCategorizationTab];
     const uncategorizedIncomeExpense = getUncategorizedAccounts(accountState, accountListState, 'accountList');
     const accountList = getAccountList(accountState, accountListState, 'accountList');
@@ -63,27 +63,10 @@ export function getExpenseAutomationTransactionView(state) {
         .uiState.totalCount;
     const totalCountByAutoCat = expenseAutomationTransactionsViewState.transactionCategorizationView
         .autoCategorized.uiState.totalCount;
-    // Per-(sub-)tab counts powering pagination, in-list "showing X of Y", and
-    // any save/refresh round-trips. Sourced from `uiState.totalCount` which
-    // mirrors the response's `total_count` for whatever tab/sub-tab the user is
-    // viewing (e.g. only the Manual sub-tab rows for Completed → Manual).
     const totalCountByTab = {
         review: monthYearPeriodId != null ? totalCountByReview[monthYearPeriodId] : 0,
         autoCategorized: monthYearPeriodId != null ? totalCountByAutoCat[monthYearPeriodId] : 0,
     };
-    // Parent-tab badge counts. Sourced from `parent_tab_total_count` in the
-    // listing response and used exclusively by the navbar / tab strip badges.
-    // Independent of which Completed sub-tab is active so the badge stays
-    // stable across sub-tab switches.
-    const parentTotalCountByTab = expenseAutomationTransactionsViewState.parentTotalCountByTab;
-    const parentTabTotalCountByTab = {
-        review: monthYearPeriodId != null
-            ? (parentTotalCountByTab.review[monthYearPeriodId] ?? 0)
-            : 0,
-        autoCategorized: monthYearPeriodId != null
-            ? (parentTotalCountByTab.autoCategorized[monthYearPeriodId] ?? 0)
-            : 0,
-    };
     const fetchStateByTab = {
         review: {
             fetchState: expenseAutomationTransactionsViewState.transactionCategorizationView
@@ -125,11 +108,9 @@ export function getExpenseAutomationTransactionView(state) {
         markAsNotMiscategorizedStatus,
         completionStatus,
         totalCountByTab,
-        parentTabTotalCountByTab,
         fetchStateByTransactionTabs: fetchStateByTab,
         uploadReceiptStatusById,
         selectedTransactionId,
         selectedTransactionLineId,
-        selectedTransactionCategorizationCompletedSubTab,
     };
 }

package/lib/esm/view/expenseAutomationView/types/missingReceiptsViewState.js

@@ -39,6 +39,8 @@ const BULK_UPLOAD_RESULTS_TABS = ['completed', 'unmatched'];
 export const toBulkUploadResultsTab = (v) => stringToUnion(v.trim().toLowerCase(), BULK_UPLOAD_RESULTS_TABS);
 const MISSING_RECEIPTS_TABS = ['missing', 'completed', 'unmatched'];
 export const toMissingReceiptsTab = (v) => stringToUnion(v.trim().toLowerCase(), MISSING_RECEIPTS_TABS);
+const COMPLETED_SUB_TABS = ['all', 'ai_accountant', 'manual'];
+export const toCompletedSubTab = (v) => stringToUnion(v.trim().toLowerCase(), COMPLETED_SUB_TABS);
 const MATCH_SOURCES = ['ai', 'manual'];
 export const toMatchSource = (v) => stringToUnion(v.trim().toLowerCase(), MATCH_SOURCES);
 const BULK_UPLOAD_SORT_KEYS = [

package/lib/esm/view/transactionDetail/journalEntryLinesViewModel.js

@@ -0,0 +1,113 @@
+import orderBy from 'lodash/orderBy';
+import { stringToUnion } from '../../commonStateTypes/stringToUnion';
+/**
+ * View-model helpers for the new Journal Entry table view (see
+ * web-components `journalEntryTable`). Keeps presentation-agnostic
+ * logic — totals, sort, line-filter — colocated in epic-state so it
+ * is testable and reusable.
+ */
+// ---------------------------------------------------------------------------
+// Sort keys
+// ---------------------------------------------------------------------------
+export const JOURNAL_ENTRY_SORT_KEYS = [
+    'description',
+    'name',
+    'category',
+    'class',
+    'debit',
+    'credit',
+];
+export const toJournalEntrySortKey = (v) => stringToUnion(v, JOURNAL_ENTRY_SORT_KEYS);
+export const journalEntryDefaultSortConfig = {
+    sortKey: 'description',
+    sortOrder: 'ascending',
+};
+/**
+ * Sums the `amount.amount` field of every line and returns an `Amount`
+ * whose currencyCode/currencySymbol are taken from the first line.
+ * Returns `undefined` for an empty list.
+ *
+ * Mirrors legacy `calculateTotal` in
+ * `web-components/src/components/transactionDetail/items/TransactionLinesJournalEntry.tsx`
+ * but without the `Object.assign` ceremony and with stable currency carry-over.
+ */
+export const sumJournalEntryAmounts = (lines) => {
+    if (lines.length === 0) {
+        return undefined;
+    }
+    const first = lines[0].amount;
+    let total = 0;
+    for (const line of lines) {
+        total += line.amount?.amount ?? 0;
+    }
+    return {
+        amount: total,
+        currencyCode: first?.currencyCode ?? '',
+        currencySymbol: first?.currencySymbol ?? '',
+    };
+};
+/**
+ * Splits `lines` by `postingType` into debit/credit totals.
+ *
+ * Fixes the operator-precedence bug from legacy
+ * `calculateCombinedTotalAmount` where
+ * `totalAmount?.amount ?? 0 + (...) + (...)` parses as
+ * `totalAmount?.amount ?? (0 + ... + ...)` so the `(...)`'s only get
+ * added when `totalAmount` is nullish. The new implementation just sums
+ * every debit (or credit) line including the un/miscategorized ones in
+ * one pass, so the result is always the true sum.
+ */
+export const journalEntryTotalsByPostingSide = (lines) => {
+    const debitLines = [];
+    const creditLines = [];
+    for (const line of lines) {
+        if (line.postingType === 'debit') {
+            debitLines.push(line);
+        }
+        else if (line.postingType === 'credit') {
+            creditLines.push(line);
+        }
+    }
+    return {
+        debitTotal: sumJournalEntryAmounts(debitLines),
+        creditTotal: sumJournalEntryAmounts(creditLines),
+    };
+};
+// ---------------------------------------------------------------------------
+// Filter
+// ---------------------------------------------------------------------------
+/**
+ * Drops `linked_transaction_line` entries — equivalent to legacy
+ * `filterOutLinkedTransactionLine` in `transactionDetail.helpers.ts`.
+ */
+export const filterJournalEntryLinesExcludingLinked = (lines) => lines?.filter((line) => line.type !== 'linked_transaction_line') ?? [];
+const sortOrderToLodash = (sortOrder) => sortOrder === 'descending' ? 'desc' : 'asc';
+/**
+ * Stable, accessor-driven sort over arbitrary line shapes. Lines that
+ * resolve to the same key value preserve their original relative order
+ * thanks to lodash's stable `orderBy`.
+ *
+ * Strings are lower-cased before comparison so the order is predictable
+ * across mixed-case data. Numbers (debit/credit) compare directly.
+ */
+export const sortJournalEntryLines = (lines, config, accessors) => {
+    const accessor = (line) => {
+        switch (config.sortKey) {
+            case 'description':
+                return accessors.description(line).toLowerCase();
+            case 'name':
+                return accessors.name(line).toLowerCase();
+            case 'category':
+                return accessors.category(line).toLowerCase();
+            case 'class':
+                return accessors.class(line).toLowerCase();
+            case 'debit':
+                return accessors.debit(line);
+            case 'credit':
+                return accessors.credit(line);
+            default:
+                return accessors.description(line).toLowerCase();
+        }
+    };
+    return orderBy([...lines], [accessor], [sortOrderToLodash(config.sortOrder)]);
+};

package/lib/esm/view/transactionDetail/journalEntryLinesViewModel.vitest.js

@@ -0,0 +1,243 @@
+import { describe, expect, it } from 'vitest';
+import { JOURNAL_ENTRY_SORT_KEYS, filterJournalEntryLinesExcludingLinked, journalEntryDefaultSortConfig, journalEntryTotalsByPostingSide, sortJournalEntryLines, sumJournalEntryAmounts, } from './journalEntryLinesViewModel';
+const usd = (amount) => ({
+    amount,
+    currencyCode: 'USD',
+    currencySymbol: '$',
+});
+const debit = (n) => ({
+    amount: usd(n),
+    postingType: 'debit',
+});
+const credit = (n) => ({
+    amount: usd(n),
+    postingType: 'credit',
+});
+describe('sumJournalEntryAmounts', () => {
+    it('returns undefined for an empty list', () => {
+        expect(sumJournalEntryAmounts([])).toBeUndefined();
+    });
+    it('sums a single line as-is', () => {
+        expect(sumJournalEntryAmounts([{ amount: usd(42) }])).toEqual(usd(42));
+    });
+    it('sums multiple lines preserving the first line currency', () => {
+        const total = sumJournalEntryAmounts([
+            { amount: usd(10) },
+            { amount: usd(20.5) },
+            { amount: usd(0.5) },
+        ]);
+        expect(total).toEqual(usd(31));
+    });
+    it('treats nullish amount.amount as 0 without crashing', () => {
+        const total = sumJournalEntryAmounts([
+            { amount: usd(10) },
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            { amount: { currencyCode: 'USD', currencySymbol: '$' } },
+            { amount: usd(5) },
+        ]);
+        expect(total).toEqual(usd(15));
+    });
+    it('uses an empty currency code/symbol when first line lacks them', () => {
+        const total = sumJournalEntryAmounts([
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            { amount: { amount: 7 } },
+            { amount: usd(3) },
+        ]);
+        expect(total).toEqual({ amount: 10, currencyCode: '', currencySymbol: '' });
+    });
+});
+describe('journalEntryTotalsByPostingSide', () => {
+    it('returns undefined totals for an empty list', () => {
+        expect(journalEntryTotalsByPostingSide([])).toEqual({
+            debitTotal: undefined,
+            creditTotal: undefined,
+        });
+    });
+    it('sums debits and credits separately when both sides present', () => {
+        const { debitTotal, creditTotal } = journalEntryTotalsByPostingSide([
+            debit(100),
+            debit(50),
+            credit(120),
+            credit(30),
+        ]);
+        expect(debitTotal).toEqual(usd(150));
+        expect(creditTotal).toEqual(usd(150));
+    });
+    it('returns only the populated side when one side is missing', () => {
+        const onlyDebits = journalEntryTotalsByPostingSide([debit(10), debit(20)]);
+        expect(onlyDebits.debitTotal).toEqual(usd(30));
+        expect(onlyDebits.creditTotal).toBeUndefined();
+        const onlyCredits = journalEntryTotalsByPostingSide([credit(99)]);
+        expect(onlyCredits.creditTotal).toEqual(usd(99));
+        expect(onlyCredits.debitTotal).toBeUndefined();
+    });
+    /**
+     * Regression test for the operator-precedence bug in legacy
+     * `calculateCombinedTotalAmount` where
+     * `totalAmount?.amount ?? 0 + (uncategorized?.amount ?? 0) + (miscategorized?.amount ?? 0)`
+     * parses as `totalAmount?.amount ?? (0 + ... + ...)`. With the bug,
+     * an existing `totalAmount` would short-circuit and the uncat/miscat
+     * pieces would be ignored. The new implementation always adds every
+     * matching line, so 100 (cat) + 25 (uncat) + 10 (miscat) = 135.
+     */
+    it('does not drop uncategorized/miscategorized contributions (precedence-bug regression)', () => {
+        const { debitTotal } = journalEntryTotalsByPostingSide([
+            debit(100),
+            debit(25),
+            debit(10),
+        ]);
+        expect(debitTotal).toEqual(usd(135));
+    });
+    it('ignores lines with neither debit nor credit posting type', () => {
+        const totals = journalEntryTotalsByPostingSide([
+            debit(40),
+            credit(40),
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            { amount: usd(999), postingType: 'unknown' },
+        ]);
+        expect(totals.debitTotal).toEqual(usd(40));
+        expect(totals.creditTotal).toEqual(usd(40));
+    });
+});
+describe('filterJournalEntryLinesExcludingLinked', () => {
+    it('returns [] for undefined input', () => {
+        expect(filterJournalEntryLinesExcludingLinked(undefined)).toEqual([]);
+    });
+    it('filters out linked_transaction_line entries', () => {
+        const lines = [
+            { id: 'a', type: 'journal_entry_transaction_line' },
+            { id: 'b', type: 'linked_transaction_line' },
+            { id: 'c', type: 'journal_entry_transaction_line' },
+        ];
+        const filtered = filterJournalEntryLinesExcludingLinked(lines);
+        expect(filtered).toHaveLength(2);
+        expect(filtered[0].id).toBe('a');
+        expect(filtered[1].id).toBe('c');
+    });
+    it('returns input unchanged when no linked lines exist', () => {
+        const lines = [
+            { id: 'a', type: 'journal_entry_transaction_line' },
+            { id: 'b', type: 'journal_entry_transaction_line' },
+        ];
+        expect(filterJournalEntryLinesExcludingLinked(lines)).toHaveLength(2);
+    });
+});
+describe('sortJournalEntryLines', () => {
+    const accessors = {
+        description: (r) => r.description,
+        name: (r) => r.name,
+        category: (r) => r.category,
+        class: (r) => r.class,
+        debit: (r) => r.debit,
+        credit: (r) => r.credit,
+    };
+    const rows = [
+        {
+            id: '1',
+            description: 'Beta',
+            name: 'Acme',
+            category: 'Rent',
+            class: 'Ops',
+            debit: 100,
+            credit: 0,
+        },
+        {
+            id: '2',
+            description: 'alpha',
+            name: 'Beta Co',
+            category: 'Travel',
+            class: 'GA',
+            debit: 200,
+            credit: 0,
+        },
+        {
+            id: '3',
+            description: 'Gamma',
+            name: 'acme',
+            category: 'Rent',
+            class: 'Sales',
+            debit: 0,
+            credit: 50,
+        },
+    ];
+    it('exposes every supported sort key via JOURNAL_ENTRY_SORT_KEYS', () => {
+        expect([...JOURNAL_ENTRY_SORT_KEYS]).toEqual([
+            'description',
+            'name',
+            'category',
+            'class',
+            'debit',
+            'credit',
+        ]);
+    });
+    it('sorts by description case-insensitively ascending by default', () => {
+        const sorted = sortJournalEntryLines(rows, journalEntryDefaultSortConfig, accessors);
+        expect(sorted.map((r) => r.id)).toEqual(['2', '1', '3']);
+    });
+    it('sorts by description descending when configured', () => {
+        const config = {
+            sortKey: 'description',
+            sortOrder: 'descending',
+        };
+        const sorted = sortJournalEntryLines(rows, config, accessors);
+        expect(sorted.map((r) => r.id)).toEqual(['3', '1', '2']);
+    });
+    it.each([
+        ['name', 'ascending', ['1', '3', '2']],
+        ['name', 'descending', ['2', '1', '3']],
+        ['category', 'ascending', ['1', '3', '2']],
+        ['class', 'ascending', ['2', '1', '3']],
+        ['debit', 'ascending', ['3', '1', '2']],
+        ['debit', 'descending', ['2', '1', '3']],
+        ['credit', 'ascending', ['1', '2', '3']],
+        ['credit', 'descending', ['3', '1', '2']],
+    ])('sorts by %s %s producing the expected order', (key, order, expected) => {
+        const config = {
+            sortKey: key,
+            sortOrder: order,
+        };
+        const sorted = sortJournalEntryLines(rows, config, accessors);
+        expect(sorted.map((r) => r.id)).toEqual([...expected]);
+    });
+    it('keeps stable order for ties on the sort key', () => {
+        const tied = [
+            {
+                id: 'a',
+                description: 'same',
+                name: '',
+                category: '',
+                class: '',
+                debit: 0,
+                credit: 0,
+            },
+            {
+                id: 'b',
+                description: 'same',
+                name: '',
+                category: '',
+                class: '',
+                debit: 0,
+                credit: 0,
+            },
+            {
+                id: 'c',
+                description: 'same',
+                name: '',
+                category: '',
+                class: '',
+                debit: 0,
+                credit: 0,
+            },
+        ];
+        const sortedAsc = sortJournalEntryLines(tied, { sortKey: 'description', sortOrder: 'ascending' }, accessors);
+        expect(sortedAsc.map((r) => r.id)).toEqual(['a', 'b', 'c']);
+        const sortedDesc = sortJournalEntryLines(tied, { sortKey: 'description', sortOrder: 'descending' }, accessors);
+        expect(sortedDesc.map((r) => r.id)).toEqual(['a', 'b', 'c']);
+    });
+    it('does not mutate the input array', () => {
+        const input = [...rows];
+        const before = input.map((r) => r.id);
+        sortJournalEntryLines(input, { sortKey: 'description', sortOrder: 'descending' }, accessors);
+        expect(input.map((r) => r.id)).toEqual(before);
+    });
+});