@zeniai/client-epic-state 5.3.22-beta0KB → 5.3.23-beta0AN

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

@@ -1,1141 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.uploadTransactionCategorizationReceiptSuccess = exports.updateTransactionCategorizationUploadReceiptState = exports.removeTransactionFromAllTabs = exports.backgroundRefetchReviewTab = exports.syncTransactionCategorizationFromDetailSave = exports.updateSelectedTransactionId = exports.markCategoryClassRecommendationsFailureForCategorization = exports.markCategoryClassRecommendationsCompletedForCategorization = exports.markCategoryClassRecommendationsInProgressForCategorization = exports.setEntityRecommendationForLineIdsForCategorization = exports.clearExpenseAutomationTransactionsView = exports.clearExpenseAutomationTransactionsViewPerTabView = exports.updateSelectedCheckboxTransactionIds = exports.fetchTransactionCategorizationView = exports.resetOtherTabsFetchState = exports.fetchTransactionCategorizationSuccess = exports.updateParentTotalCountForTab = exports.updateTotalCountForTransactionCategorization = exports.setAllItemsToCategoryClassInLocalDataForCategorization = exports.updateSelectedCustomerForTransaction = exports.updateSelectedVendorForTransaction = exports.updateStatusForTransactionNotMiscategorizedUpdateForCategorization = exports.markTransactionAsNotMiscategorized = exports.updateTransactionCategorizationSaveStatus = exports.updateTransactionGroup = exports.updateTransactionCategorizationCompletedSubTab = exports.updateCurrentSelectedTransactionCategorizationTab = exports.updateTransactionCategorization = exports.saveTransactionCategorization = exports.fetchTransactionCategorizationFailure = exports.saveTransactionCategorizationLocalData = exports.initializeTransactionCategorizationViewLocalData = exports.updateTransactionFilters = exports.updateTransactionCategorizationUIState = exports.fetchTransactionCategorization = exports.initialState = exports.initialTransactionTabViewState = exports.initialUIState = void 0;
-const toolkit_1 = require("@reduxjs/toolkit");
-const get_1 = __importDefault(require("lodash/get"));
-const uniq_1 = __importDefault(require("lodash/uniq"));
-const timePeriod_1 = require("../../../commonStateTypes/timePeriod");
-const vendorTransaction_1 = require("../../../entity/transaction/stateTypes/vendorTransaction");
-const rootActions_1 = require("../../../rootActions");
-const transactionCategorizationLocalDataHelper_1 = require("../helpers/transactionCategorizationLocalDataHelper");
-const completedSubTab_1 = require("../types/completedSubTab");
-const transactionGroup_1 = require("../types/transactionGroup");
-const transactionsViewState_1 = require("../types/transactionsViewState");
-exports.initialUIState = {
-    sortKey: 'date',
-    sortOrder: 'descending',
-    searchString: '',
-    nodeCollapseState: {},
-    scrollPosition: { scrollTop: 0, scrollLeft: undefined },
-    pageToken: null,
-    totalCount: {},
-    limit: 10,
-};
-exports.initialTransactionTabViewState = {
-    saveStatus: {
-        fetchState: 'Not-Started',
-        error: undefined,
-    },
-    refreshStatus: {
-        fetchState: 'Not-Started',
-        error: undefined,
-    },
-    markAsNotMiscategorizedStatus: {
-        fetchState: 'Not-Started',
-        error: undefined,
-    },
-    uiState: { ...exports.initialUIState },
-    filters: {
-        categoryCombinationOperator: 'AND',
-        categories: [],
-    },
-    fetchState: 'Not-Started',
-    error: undefined,
-    hasValidState() {
-        return this.fetchState == 'Completed';
-    },
-    transactionReviewLocalDataById: {},
-    transactionIdsBySelectedPeriod: {},
-    selectedCheckBoxTransactionIds: [],
-    transactionIdsWithUnsavedData: [],
-    uploadReceiptStatusById: {},
-    selectedTransactionId: undefined,
-    selectedTransactionLineId: undefined,
-};
-exports.initialState = {
-    autoCategorizedSubTabCache: {},
-    parentTotalCountByTab: {
-        review: {},
-        autoCategorized: {},
-    },
-    selectedTransactionCategorizationTab: 'review',
-    selectedTransactionCategorizationCompletedSubTab: completedSubTab_1.DEFAULT_COMPLETED_SUB_TAB,
-    selectedTransactionGroup: transactionGroup_1.DEFAULT_TRANSACTION_GROUP,
-    transactionCategorizationView: {
-        review: { ...exports.initialTransactionTabViewState },
-        autoCategorized: { ...exports.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.
- *
- * Snapshot scope (deliberately narrow):
- * - Captured: `pageToken`, `totalCount`, `transactionIdsBySelectedPeriod`,
- *   `fetchState`, `error`, `scrollPosition`. The first five are the keys the
- *   fetch epic's cache check reads to decide whether to short-circuit a
- *   sub-tab revisit; `scrollPosition` is captured per sub-tab so revisiting
- *   restores the user's last offset and switching to a never-visited sub-tab
- *   starts at the top instead of inheriting the outgoing sub-tab's offset
- *   (which would land the user at a meaningless row index against a
- *   completely different list).
- * - Intentionally NOT captured (left in place on `autoCat` and inherited by
- *   the incoming sub-tab):
- *     - `uiState.searchString`, `uiState.sortKey`, `uiState.sortOrder`,
- *       `uiState.nodeCollapseState`, `uiState.limit` — search and sort are
- *       user-applied preferences that persist across sub-tabs by design (a
- *       search query stays active when the user toggles between Manual / AI
- *       Accountant).
- *     - `selectedCheckBoxTransactionIds` — selection state is intentionally
- *       cleared at the action source (the fetch epic / save flow), not
- *       by the snapshot path. Carrying selection across sub-tabs is safe
- *       because every sub-tab change goes through a fetch round-trip that
- *       reconciles selection against the new row IDs.
- *     - `transactionReviewLocalDataById`, `transactionIdsWithUnsavedData`,
- *       `uploadReceiptStatusById`, `saveStatus`, `refreshStatus`,
- *       `markAsNotMiscategorizedStatus` — these are per-row / per-flight
- *       caches that are write-through global state, not sub-tab-scoped.
- *
- * If the contract changes (e.g. selection should reset on every sub-tab
- * switch), update both this comment and the snapshot return shape together.
- */
-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,
-        scrollPosition: autoCat.uiState.scrollPosition,
-        totalCount: { ...autoCat.uiState.totalCount },
-        transactionIdsBySelectedPeriod,
-    };
-}
-const expenseAutomationTransactionsView = (0, toolkit_1.createSlice)({
-    name: 'expenseAutomationTransactionsView',
-    initialState: exports.initialState,
-    reducers: {
-        fetchTransactionCategorizationView: {
-            prepare(selectedTab, period, cacheOverride = false, keepExistingListItems = false, searchString, // when this is defined the output should go to search result IDs
-            pageToken, refreshViewInBackground = false, resetListItems = false) {
-                return {
-                    payload: {
-                        selectedTab,
-                        period,
-                        searchString,
-                        keepExistingListItems,
-                        pageToken,
-                        cacheOverride,
-                        refreshViewInBackground,
-                        resetListItems,
-                    },
-                };
-            },
-            reducer() {
-                // do nothing
-            },
-        },
-        fetchTransactionCategorization: {
-            reducer(draft, action) {
-                const { refreshViewInBackground, resetListItems, selectedTab, pageToken, searchString, period, } = action.payload;
-                if (refreshViewInBackground === true) {
-                    draft.transactionCategorizationView[selectedTab].refreshStatus = {
-                        fetchState: 'In-Progress',
-                        error: undefined,
-                    };
-                }
-                else {
-                    draft.transactionCategorizationView[selectedTab].fetchState =
-                        'In-Progress';
-                    draft.transactionCategorizationView[selectedTab].error = undefined;
-                    // A foreground fetch supersedes any in-flight background preload.
-                    // Reset refreshStatus so a cancelled preload doesn't leave the
-                    // spinner stuck at In-Progress.
-                    draft.transactionCategorizationView[selectedTab].refreshStatus = {
-                        fetchState: 'Not-Started',
-                        error: undefined,
-                    };
-                }
-                draft.transactionCategorizationView[selectedTab].uiState.pageToken =
-                    pageToken ?? null;
-                // Only overwrite when explicitly set; undefined means a non-search fetch
-                // (tab switch, period change) should preserve the existing search string.
-                if (searchString !== undefined) {
-                    draft.transactionCategorizationView[selectedTab].uiState.searchString = searchString;
-                    // When search is cleared, drop all sub-tab snapshots. A snapshot
-                    // captured while search was active holds filtered row IDs — restoring
-                    // it after the clear would show stale search results instead of the
-                    // full unfiltered list.
-                    if (searchString === '' && selectedTab === 'autoCategorized') {
-                        draft.autoCategorizedSubTabCache = {};
-                    }
-                }
-                draft.transactionCategorizationView[selectedTab].error = undefined;
-                const monthYearPeriod = {
-                    month: period.start.month,
-                    year: period.start.year,
-                };
-                const periodId = (0, timePeriod_1.toMonthYearPeriodId)(monthYearPeriod);
-                const transactionIdsBySelectedPeriod = draft.transactionCategorizationView[selectedTab]
-                    .transactionIdsBySelectedPeriod[periodId] ?? [];
-                // Reset list when we change the sort order and fetch list again
-                if (resetListItems === true) {
-                    transactionIdsBySelectedPeriod.forEach((transactionId) => {
-                        delete draft.transactionCategorizationView[selectedTab]
-                            .transactionReviewLocalDataById[transactionId];
-                    });
-                    draft.transactionCategorizationView[selectedTab].selectedCheckBoxTransactionIds =
-                        draft.transactionCategorizationView[selectedTab].selectedCheckBoxTransactionIds.filter((selectedCheckBoxTransactionId) => transactionIdsBySelectedPeriod.includes(selectedCheckBoxTransactionId));
-                    draft.transactionCategorizationView[selectedTab].transactionIdsBySelectedPeriod[periodId] = [];
-                    draft.transactionCategorizationView[selectedTab].refreshStatus = {
-                        fetchState: 'Not-Started',
-                        error: undefined,
-                    };
-                }
-            },
-            prepare(selectedTab, period, cacheOverride = false, keepExistingListItems = false, searchString, // when this is defined the output should go to search result IDs
-            pageToken, refreshViewInBackground = false, resetListItems) {
-                return {
-                    payload: {
-                        selectedTab,
-                        period,
-                        searchString,
-                        keepExistingListItems,
-                        pageToken,
-                        cacheOverride,
-                        refreshViewInBackground,
-                        resetListItems,
-                    },
-                };
-            },
-        },
-        initializeTransactionCategorizationViewLocalData: {
-            prepare(selectedTab, transactionIds, selectedPeriod, keepExistingListItems = false, pageToken, totalCount, lineItemsByTransactionIds, refreshViewInBackground = false) {
-                return {
-                    payload: {
-                        selectedTab,
-                        transactionIds,
-                        selectedPeriod,
-                        keepExistingListItems,
-                        pageToken,
-                        totalCount,
-                        lineItemsByTransactionIds,
-                        refreshViewInBackground,
-                    },
-                };
-            },
-            reducer() {
-                // do nothing
-            },
-        },
-        saveTransactionCategorizationLocalData(draft, action) {
-            const { keepExistingListItems, transactionIds, transactionLocalData, selectedPeriod, selectedTab, pageToken, totalCount, } = action.payload;
-            if (keepExistingListItems === false) {
-                draft.transactionCategorizationView[selectedTab].transactionIdsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] =
-                    transactionIds;
-                draft.transactionCategorizationView[selectedTab].selectedCheckBoxTransactionIds = [];
-                // Reset dirty transaction IDs on page load/refresh
-                draft.transactionCategorizationView[selectedTab].transactionIdsWithUnsavedData = [];
-            }
-            else {
-                const previousData = draft.transactionCategorizationView[selectedTab]
-                    .transactionIdsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)];
-                if (previousData == null) {
-                    draft.transactionCategorizationView[selectedTab].transactionIdsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] = transactionIds;
-                }
-                else {
-                    const combinedData = (0, uniq_1.default)([...previousData, ...transactionIds]);
-                    draft.transactionCategorizationView[selectedTab].transactionIdsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] = [...combinedData];
-                }
-            }
-            draft.transactionCategorizationView[selectedTab].transactionReviewLocalDataById = {
-                ...draft.transactionCategorizationView[selectedTab]
-                    .transactionReviewLocalDataById,
-                ...Object.fromEntries(Object.entries(transactionLocalData).map(([transactionId, newData]) => {
-                    const existingData = draft.transactionCategorizationView[selectedTab]
-                        .transactionReviewLocalDataById[transactionId];
-                    // If keepExistingListItems is false, preserve existing tabSpecificLineItems
-                    if (keepExistingListItems === false && existingData != null) {
-                        return [
-                            transactionId,
-                            {
-                                ...newData,
-                                transactionReviewLocalData: {
-                                    ...newData.transactionReviewLocalData,
-                                    tabSpecificLineItems: (0, transactionCategorizationLocalDataHelper_1.mergeTabSpecificLineItems)(existingData.transactionReviewLocalData
-                                        .tabSpecificLineItems, selectedTab, newData.transactionReviewLocalData.tabSpecificLineItems),
-                                },
-                            },
-                        ];
-                    }
-                    return [transactionId, newData];
-                })),
-            };
-            if (action.payload.refreshViewInBackground === true) {
-                draft.transactionCategorizationView[selectedTab].refreshStatus = {
-                    fetchState: 'Completed',
-                    error: undefined,
-                };
-            }
-            else {
-                draft.transactionCategorizationView[selectedTab].fetchState =
-                    'Completed';
-                draft.transactionCategorizationView[selectedTab].error = undefined;
-            }
-            draft.transactionCategorizationView[selectedTab].uiState = {
-                ...draft.transactionCategorizationView[selectedTab].uiState,
-                pageToken: pageToken ?? null,
-            };
-            draft.transactionCategorizationView[selectedTab].uiState.totalCount[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] = totalCount;
-        },
-        updateTransactionCategorizationUIState(draft, action) {
-            const selectedTab = action.payload.selectedTab;
-            const uiState = action.payload.uiState;
-            if (uiState.sortKey != null) {
-                draft.transactionCategorizationView[selectedTab].uiState.sortKey =
-                    uiState.sortKey;
-            }
-            if (uiState.sortOrder != null) {
-                draft.transactionCategorizationView[selectedTab].uiState.sortOrder =
-                    uiState.sortOrder;
-            }
-            if (uiState.searchString != null) {
-                draft.transactionCategorizationView[selectedTab].uiState.searchString =
-                    uiState.searchString;
-            }
-            if (uiState.scrollPosition != null) {
-                draft.transactionCategorizationView[selectedTab].uiState.scrollPosition = uiState.scrollPosition;
-            }
-            if (uiState.pageToken != null) {
-                draft.transactionCategorizationView[selectedTab].uiState.pageToken =
-                    uiState.pageToken;
-            }
-            if (uiState.totalCount != null) {
-                draft.transactionCategorizationView[selectedTab].uiState.totalCount =
-                    uiState.totalCount;
-            }
-        },
-        updateTransactionFilters(draft, action) {
-            const { filters } = action.payload;
-            // Filters are tab-agnostic (payee/category/class/amount), so apply to
-            // all tabs so switching tabs after filtering shows consistent results.
-            transactionsViewState_1.TRANSACTIONS_TABS.forEach((tab) => {
-                draft.transactionCategorizationView[tab].filters = filters;
-            });
-        },
-        saveTransactionCategorization: {
-            prepare(selectedTab, transactionIds, cotTrackingByTransactionId) {
-                return {
-                    payload: {
-                        selectedTab,
-                        transactionIds,
-                        cotTrackingByTransactionId,
-                    },
-                };
-            },
-            reducer() {
-                // do nothing
-            },
-        },
-        updateCurrentSelectedTransactionCategorizationTab: {
-            reducer(draft, action) {
-                draft.selectedTransactionCategorizationTab =
-                    action.payload.newSelectedTab;
-            },
-            prepare(newSelectedTab) {
-                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 };
-                    // Keep the stored badge in step with the restored sub-tab: the selector
-                    // falls back to it for any period this sub-tab has not loaded. Merged,
-                    // not replaced -- the snapshot only holds periods this sub-tab actually
-                    // loaded, while the badge map also carries periods filled from a Review
-                    // response's `other_tab_total_count`. Overwriting would drop those and
-                    // leave the badge at 0 for any period this sub-tab never visited.
-                    draft.parentTotalCountByTab.autoCategorized = {
-                        ...draft.parentTotalCountByTab.autoCategorized,
-                        ...cached.totalCount,
-                    };
-                    autoCat.uiState.scrollPosition = cached.scrollPosition;
-                    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. `scrollPosition` is reset to the top
-                    // so the incoming list isn't anchored to the outgoing sub-tab's
-                    // offset (different rows → previous offset is meaningless).
-                    autoCat.uiState.pageToken = null;
-                    autoCat.uiState.totalCount = {};
-                    autoCat.uiState.scrollPosition = {
-                        scrollTop: 0,
-                        scrollLeft: undefined,
-                    };
-                    autoCat.transactionIdsBySelectedPeriod = {};
-                    autoCat.fetchState = 'Not-Started';
-                    autoCat.error = undefined;
-                }
-                draft.selectedTransactionCategorizationCompletedSubTab = newSubTab;
-            },
-            prepare(newSubTab) {
-                return { payload: { newSubTab } };
-            },
-        },
-        updateTransactionGroup: {
-            reducer(draft, action) {
-                const { newGroup } = action.payload;
-                if (draft.selectedTransactionGroup === newGroup) {
-                    return;
-                }
-                draft.selectedTransactionGroup = newGroup;
-                // A group change re-scopes the entire dataset on the backend (by
-                // account_type), so every parent tab, sub-tab snapshot and count is now
-                // stale. Drop the sub-tab cache and parent counts, and reset each tab's
-                // paginated data slots so the view epic's cache check falls through to a
-                // fresh page-1 fetch. User preferences (search, sort, limit, collapse
-                // state) are intentionally preserved, mirroring the sub-tab switch.
-                draft.autoCategorizedSubTabCache = {};
-                draft.parentTotalCountByTab = { review: {}, autoCategorized: {} };
-                transactionsViewState_1.TRANSACTIONS_TABS.forEach((tab) => {
-                    const view = draft.transactionCategorizationView[tab];
-                    // Reset uiState to its initial values but keep the user prefs (search,
-                    // sort, limit, collapse) in place -- mirroring the sub-tab switch. Then
-                    // drop the loaded rows and any stale selection pointing at a now-absent
-                    // row to avoid transient invalid state.
-                    const { searchString, sortKey, sortOrder, nodeCollapseState, limit } = view.uiState;
-                    view.uiState = {
-                        ...exports.initialUIState,
-                        searchString,
-                        sortKey,
-                        sortOrder,
-                        nodeCollapseState,
-                        limit,
-                    };
-                    view.transactionIdsBySelectedPeriod = {};
-                    view.fetchState = 'Not-Started';
-                    view.error = undefined;
-                    view.selectedTransactionId = undefined;
-                    view.selectedTransactionLineId = undefined;
-                    view.selectedCheckBoxTransactionIds = [];
-                });
-            },
-            prepare(newGroup) {
-                return { payload: { newGroup } };
-            },
-        },
-        updateTransactionCategorization: {
-            reducer(draft, action) {
-                const selectedTab = action.payload.selectedTab;
-                draft.transactionCategorizationView[selectedTab].saveStatus = {
-                    error: undefined,
-                    fetchState: 'In-Progress',
-                };
-            },
-            prepare(selectedTab, transactionIds, transactionSaveUpdates, cotTrackingByTransactionId) {
-                return {
-                    payload: {
-                        selectedTab,
-                        transactionIds,
-                        transactionSaveUpdates,
-                        cotTrackingByTransactionId,
-                    },
-                };
-            },
-        },
-        setAllItemsToCategoryClassInLocalDataForCategorization: {
-            reducer(draft, action) {
-                const { vendorId, customerId, selectedAccount, selectedClassBase, selectedProjectBase, transactions, transactionId, lineId, selectedTab, isAccountingClassesEnabled, } = action.payload;
-                const transactionLocalData = (0, get_1.default)(draft.transactionCategorizationView[selectedTab]
-                    .transactionReviewLocalDataById, transactionId, undefined);
-                const existingAccount = transactionLocalData?.transactionReviewLocalData.lineItemById[lineId]
-                    .account;
-                if (transactionLocalData != null) {
-                    const newTransactionLocalData = {
-                        ...transactionLocalData.transactionReviewLocalData,
-                        lineItemById: {
-                            ...transactionLocalData.transactionReviewLocalData.lineItemById,
-                            [lineId]: {
-                                ...transactionLocalData.transactionReviewLocalData.lineItemById[lineId],
-                                account: selectedAccount,
-                                class: selectedClassBase,
-                                project: selectedProjectBase,
-                            },
-                        },
-                    };
-                    draft.transactionCategorizationView[selectedTab].transactionReviewLocalDataById[transactionId] = {
-                        transactionReviewLocalData: newTransactionLocalData,
-                        transactionId,
-                    };
-                    const selectedTransaction = transactions.find((transaction) => transaction.id === transactionId);
-                    const selectedCheckBoxTransactionIds = draft.transactionCategorizationView[selectedTab]
-                        .selectedCheckBoxTransactionIds;
-                    if (selectedTransaction != null &&
-                        (0, transactionCategorizationLocalDataHelper_1.shouldAutoSelectAndAdd)(selectedTransaction, newTransactionLocalData, selectedCheckBoxTransactionIds, isAccountingClassesEnabled)) {
-                        draft.transactionCategorizationView[selectedTab].selectedCheckBoxTransactionIds = [
-                            ...selectedCheckBoxTransactionIds,
-                            transactionId,
-                        ];
-                    }
-                }
-                // Track dirty transaction IDs - always mark current transaction as dirty
-                const dirtyIds = [transactionId];
-                if (vendorId != null || customerId != null) {
-                    transactions.forEach((transaction) => {
-                        const transactionLocalData = (0, get_1.default)(draft.transactionCategorizationView[selectedTab]
-                            .transactionReviewLocalDataById, transaction.id, undefined);
-                        if (transactionLocalData != null) {
-                            const existingClassId = transactionLocalData.transactionReviewLocalData.lineItemById[lineId]?.class?.classId;
-                            const existingProjectId = transactionLocalData.transactionReviewLocalData.lineItemById[lineId]?.project?.projectId;
-                            const updatedItem = existingAccount?.accountId !== selectedAccount?.accountId
-                                ? 'category'
-                                : existingClassId !== selectedClassBase?.classId
-                                    ? 'class'
-                                    : existingProjectId !== selectedProjectBase?.projectId
-                                        ? 'project'
-                                        : 'class';
-                            const { localData, similarTransactionUpdated } = (0, transactionCategorizationLocalDataHelper_1.toSetAllLineItemsToCategoryClass)(draft.transactionCategorizationView[selectedTab], transaction, transactionId, lineId, transactionLocalData.transactionReviewLocalData, updatedItem, selectedTab, vendorId, customerId, selectedAccount, selectedClassBase, selectedProjectBase, isAccountingClassesEnabled);
-                            draft.transactionCategorizationView[selectedTab].transactionReviewLocalDataById[transaction.id] = {
-                                transactionId: transaction.id,
-                                transactionReviewLocalData: localData,
-                            };
-                            // Mark similar transaction as dirty only if it was actually updated
-                            if (similarTransactionUpdated) {
-                                dirtyIds.push(transaction.id);
-                            }
-                        }
-                    });
-                }
-                // Add all affected transaction IDs to dirty list
-                draft.transactionCategorizationView[selectedTab].transactionIdsWithUnsavedData = (0, uniq_1.default)([
-                    ...draft.transactionCategorizationView[selectedTab]
-                        .transactionIdsWithUnsavedData,
-                    ...dirtyIds,
-                ]);
-            },
-            prepare(selectedTab, transactionId, lineId, transactions, uncategorizedAccounts, vendorId, customerId, selectedAccount, selectedClassBase, lineEntity, recommendations, isAccountingClassesEnabled, selectedProjectBase) {
-                return {
-                    payload: {
-                        selectedTab,
-                        transactionId,
-                        lineId,
-                        transactions,
-                        vendorId,
-                        customerId,
-                        lineEntity,
-                        selectedAccount,
-                        selectedClassBase,
-                        selectedProjectBase,
-                        recommendations,
-                        uncategorizedAccounts,
-                        isAccountingClassesEnabled,
-                    },
-                };
-            },
-        },
-        setEntityRecommendationForLineIdsForCategorization: {
-            prepare(selectedTab, transactionId, transaction, lineIds, entity, amount, recommendationWithCOTByLineId, uncategorizedAccounts, isAccountingClassesEnabled) {
-                return {
-                    payload: {
-                        selectedTab,
-                        transactionId,
-                        transaction,
-                        lineIds,
-                        entity,
-                        amount,
-                        recommendationWithCOTByLineId,
-                        uncategorizedAccounts,
-                        isAccountingClassesEnabled,
-                    },
-                };
-            },
-            reducer(draft, action) {
-                const { entity, transaction, transactionId, selectedTab, lineIds, isAccountingClassesEnabled, } = action.payload;
-                const transactionLocalData = (0, get_1.default)(draft.transactionCategorizationView[selectedTab]
-                    .transactionReviewLocalDataById, transactionId.id, undefined);
-                if (transactionLocalData != null) {
-                    const newLocalData = (0, transactionCategorizationLocalDataHelper_1.setEntityRecommendationForLineIdInLocalData)(draft.transactionCategorizationView[selectedTab], transaction, transactionLocalData.transactionReviewLocalData, entity, lineIds, action.payload.recommendationWithCOTByLineId, isAccountingClassesEnabled);
-                    // Release the per-line fetch flag for every line this fetch
-                    // covered. Done in-place on the freshly returned local data
-                    // (the helper produces a new mutable object), before we write
-                    // it back to the draft.
-                    lineIds.forEach((lineId) => {
-                        const lineItem = newLocalData.lineItemById[lineId];
-                        if (lineItem != null) {
-                            newLocalData.lineItemById[lineId] = {
-                                ...lineItem,
-                                categoryClassRecommendationsFetchState: {
-                                    fetchState: 'Completed',
-                                    error: undefined,
-                                },
-                            };
-                        }
-                    });
-                    draft.transactionCategorizationView[selectedTab].transactionReviewLocalDataById[transaction.id] = {
-                        transactionId: transaction.id,
-                        transactionReviewLocalData: newLocalData,
-                    };
-                    // Mark transaction as dirty (autofill happened)
-                    if (!draft.transactionCategorizationView[selectedTab].transactionIdsWithUnsavedData.includes(transaction.id)) {
-                        draft.transactionCategorizationView[selectedTab].transactionIdsWithUnsavedData = [
-                            ...draft.transactionCategorizationView[selectedTab]
-                                .transactionIdsWithUnsavedData,
-                            transaction.id,
-                        ];
-                    }
-                }
-            },
-        },
-        // Start arm of the line-update recommendations fetch. Flips covered
-        // lines to In-Progress AND removes the transaction from
-        // selectedCheckBoxTransactionIds — the row is unchecked + disabled
-        // until either the success arm (recheck if limit allows) or the
-        // failure arm releases the per-line flag.
-        markCategoryClassRecommendationsInProgressForCategorization: {
-            reducer(draft, action) {
-                const { selectedTab, transactionId, lineIds } = action.payload;
-                const tab = draft.transactionCategorizationView[selectedTab];
-                const transactionLocalData = (0, get_1.default)(tab.transactionReviewLocalDataById, transactionId.id, undefined);
-                if (transactionLocalData != null) {
-                    lineIds.forEach((lineId) => {
-                        const lineItem = transactionLocalData.transactionReviewLocalData.lineItemById[lineId];
-                        if (lineItem != null) {
-                            transactionLocalData.transactionReviewLocalData.lineItemById[lineId] = {
-                                ...lineItem,
-                                categoryClassRecommendationsFetchState: {
-                                    fetchState: 'In-Progress',
-                                    error: undefined,
-                                },
-                            };
-                        }
-                    });
-                }
-                // Uncheck on fetch start: the row's existing category/class are
-                // stale after a payee change, so we drop the auto-selection until
-                // fresh recommendations land.
-                if (tab.selectedCheckBoxTransactionIds.includes(transactionId.id)) {
-                    tab.selectedCheckBoxTransactionIds =
-                        tab.selectedCheckBoxTransactionIds.filter((id) => id !== transactionId.id);
-                }
-            },
-            prepare(selectedTab, transactionId, lineIds) {
-                return { payload: { selectedTab, transactionId, lineIds } };
-            },
-        },
-        // Completed arm. Used by the epic when the HTTP call succeeds but the
-        // server returned no per-line recommendations — we still need to
-        // release the In-Progress flag so the skeleton resolves. Successful
-        // responses with recommendations go through
-        // setEntityRecommendationForLineIdsForCategorization instead (which
-        // also flips the lines to Completed).
-        markCategoryClassRecommendationsCompletedForCategorization: {
-            reducer(draft, action) {
-                const { selectedTab, transactionId, lineIds } = action.payload;
-                const transactionLocalData = (0, get_1.default)(draft.transactionCategorizationView[selectedTab]
-                    .transactionReviewLocalDataById, transactionId.id, undefined);
-                if (transactionLocalData != null) {
-                    lineIds.forEach((lineId) => {
-                        const lineItem = transactionLocalData.transactionReviewLocalData.lineItemById[lineId];
-                        if (lineItem != null) {
-                            transactionLocalData.transactionReviewLocalData.lineItemById[lineId] = {
-                                ...lineItem,
-                                categoryClassRecommendationsFetchState: {
-                                    fetchState: 'Completed',
-                                    error: undefined,
-                                },
-                            };
-                        }
-                    });
-                }
-            },
-            prepare(selectedTab, transactionId, lineIds) {
-                return { payload: { selectedTab, transactionId, lineIds } };
-            },
-        },
-        // Failure arm. Flips covered lines to Error so the skeleton resolves
-        // and downstream UI can react to the failure. The transaction stays
-        // unchecked from the start-arm action.
-        markCategoryClassRecommendationsFailureForCategorization: {
-            reducer(draft, action) {
-                const { selectedTab, transactionId, lineIds, error } = action.payload;
-                const transactionLocalData = (0, get_1.default)(draft.transactionCategorizationView[selectedTab]
-                    .transactionReviewLocalDataById, transactionId.id, undefined);
-                if (transactionLocalData != null) {
-                    lineIds.forEach((lineId) => {
-                        const lineItem = transactionLocalData.transactionReviewLocalData.lineItemById[lineId];
-                        if (lineItem != null) {
-                            transactionLocalData.transactionReviewLocalData.lineItemById[lineId] = {
-                                ...lineItem,
-                                categoryClassRecommendationsFetchState: {
-                                    fetchState: 'Error',
-                                    error,
-                                },
-                            };
-                        }
-                    });
-                }
-            },
-            prepare(selectedTab, transactionId, lineIds, error) {
-                return { payload: { selectedTab, transactionId, lineIds, error } };
-            },
-        },
-        fetchTransactionCategorizationSuccess(draft, action) {
-            const { selectedTab, refreshViewInBackground } = action.payload;
-            if (draft.transactionCategorizationView[selectedTab].fetchState ===
-                'In-Progress' ||
-                refreshViewInBackground !== true) {
-                draft.transactionCategorizationView[selectedTab].fetchState =
-                    'Completed';
-                draft.transactionCategorizationView[selectedTab].error = undefined;
-            }
-            else {
-                draft.transactionCategorizationView[selectedTab].refreshStatus = {
-                    fetchState: 'Completed',
-                    error: undefined,
-                };
-            }
-        },
-        resetOtherTabsFetchState(draft, action) {
-            const { tabs, refreshViewInBackground } = action.payload;
-            tabs.forEach((tab) => {
-                const tabFetchState = draft.transactionCategorizationView[tab].fetchState;
-                if (refreshViewInBackground !== true) {
-                    // Foreground fetch completed: mark other tabs as Completed.
-                    draft.transactionCategorizationView[tab].fetchState = 'Completed';
-                    draft.transactionCategorizationView[tab].error = undefined;
-                }
-                else if (tabFetchState !== 'In-Progress') {
-                    // Background fetch completed: reset the other tab's refreshStatus,
-                    // but only when it is not mid-load. During a dual-search the active
-                    // tab has its own foreground fetch in flight — clobbering its
-                    // fetchState here would drop the skeleton and show an empty list.
-                    draft.transactionCategorizationView[tab].refreshStatus = {
-                        fetchState: 'Not-Started',
-                        error: undefined,
-                    };
-                }
-                // If tabFetchState === 'In-Progress' and refreshViewInBackground === true,
-                // leave the other tab's state untouched — it has its own active fetch.
-            });
-        },
-        fetchTransactionCategorizationFailure(draft, action) {
-            const { selectedTab, selectedPeriod } = action.payload;
-            draft.transactionCategorizationView[selectedTab].transactionIdsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] =
-                [];
-            draft.transactionCategorizationView[selectedTab].fetchState = 'Error';
-            draft.transactionCategorizationView[selectedTab].error =
-                action.payload.status;
-        },
-        updateSelectedCustomerForTransaction(draft, action) {
-            const { transactionId, lineId, updatedCustomer, selectedTransaction, selectedTab, isAccountingClassesEnabled, } = action.payload;
-            const transactionLocalData = (0, get_1.default)(draft.transactionCategorizationView[selectedTab]
-                .transactionReviewLocalDataById, transactionId, undefined);
-            if (transactionLocalData != null) {
-                let newTransactionLocalData = {
-                    ...transactionLocalData.transactionReviewLocalData,
-                };
-                if (!(0, vendorTransaction_1.isVendorTransaction)(selectedTransaction) &&
-                    updatedCustomer != null) {
-                    newTransactionLocalData = {
-                        ...newTransactionLocalData,
-                        lineItemById: {
-                            ...transactionLocalData.transactionReviewLocalData.lineItemById,
-                            [lineId]: {
-                                ...transactionLocalData.transactionReviewLocalData.lineItemById[lineId],
-                                customer: updatedCustomer,
-                                selectedEntityLine: action.payload.selectedEntity != null
-                                    ? action.payload.selectedEntity
-                                    : undefined,
-                            },
-                        },
-                    };
-                }
-                else {
-                    if (action.payload.selectedEntity != null) {
-                        newTransactionLocalData.selectedEntity =
-                            action.payload.selectedEntity;
-                    }
-                    newTransactionLocalData.customerUpdates =
-                        updatedCustomer != null && updatedCustomer.id != null
-                            ? {
-                                id: updatedCustomer.id,
-                                name: updatedCustomer.name,
-                                qboId: updatedCustomer.id,
-                            }
-                            : undefined;
-                    newTransactionLocalData.customer =
-                        updatedCustomer != null && updatedCustomer.id != null
-                            ? {
-                                id: updatedCustomer.id,
-                                name: updatedCustomer.name,
-                                logo: updatedCustomer.logo,
-                            }
-                            : undefined;
-                }
-                draft.transactionCategorizationView[selectedTab].transactionReviewLocalDataById[transactionId] = {
-                    transactionReviewLocalData: newTransactionLocalData,
-                    transactionId,
-                };
-                const selectedCheckBoxTransactionIds = draft.transactionCategorizationView[selectedTab]
-                    .selectedCheckBoxTransactionIds;
-                if (newTransactionLocalData.customer != null &&
-                    newTransactionLocalData.customer.id != null &&
-                    (0, transactionCategorizationLocalDataHelper_1.shouldAutoSelectAndAdd)(selectedTransaction, newTransactionLocalData, selectedCheckBoxTransactionIds, isAccountingClassesEnabled)) {
-                    draft.transactionCategorizationView[selectedTab].selectedCheckBoxTransactionIds = [
-                        ...selectedCheckBoxTransactionIds,
-                        transactionId,
-                    ];
-                }
-                // Mark transaction as dirty (customer updated)
-                if (!draft.transactionCategorizationView[selectedTab].transactionIdsWithUnsavedData.includes(transactionId)) {
-                    draft.transactionCategorizationView[selectedTab].transactionIdsWithUnsavedData = [
-                        ...draft.transactionCategorizationView[selectedTab]
-                            .transactionIdsWithUnsavedData,
-                        transactionId,
-                    ];
-                }
-            }
-        },
-        updateSelectedVendorForTransaction(draft, action) {
-            const { transactionId, lineId, updatedVendor, selectedTransaction, selectedTab, isAccountingClassesEnabled, } = action.payload;
-            const transactionLocalData = (0, get_1.default)(draft.transactionCategorizationView[selectedTab]
-                .transactionReviewLocalDataById, transactionId, undefined);
-            if (transactionLocalData != null) {
-                let newTransactionLocalData = {
-                    ...transactionLocalData.transactionReviewLocalData,
-                };
-                if (!(0, vendorTransaction_1.isVendorTransaction)(selectedTransaction) &&
-                    updatedVendor != null) {
-                    newTransactionLocalData = {
-                        ...newTransactionLocalData,
-                        lineItemById: {
-                            ...transactionLocalData.transactionReviewLocalData.lineItemById,
-                            [lineId]: {
-                                ...transactionLocalData.transactionReviewLocalData.lineItemById[lineId],
-                                vendor: updatedVendor,
-                                selectedEntityLine: action.payload.selectedEntity != null
-                                    ? action.payload.selectedEntity
-                                    : undefined,
-                            },
-                        },
-                    };
-                }
-                else {
-                    if (action.payload.selectedEntity != null) {
-                        newTransactionLocalData.selectedEntity =
-                            action.payload.selectedEntity;
-                    }
-                    newTransactionLocalData.vendorUpdates =
-                        updatedVendor != null && updatedVendor.id != null
-                            ? {
-                                id: updatedVendor.id,
-                                name: updatedVendor.name,
-                                qboId: updatedVendor.id,
-                            }
-                            : undefined;
-                    newTransactionLocalData.vendor =
-                        updatedVendor != null && updatedVendor.id != null
-                            ? {
-                                id: updatedVendor.id,
-                                name: updatedVendor.name,
-                                logo: updatedVendor.logo,
-                            }
-                            : undefined;
-                }
-                draft.transactionCategorizationView[selectedTab].transactionReviewLocalDataById[transactionId] = {
-                    transactionReviewLocalData: {
-                        ...newTransactionLocalData,
-                        tabSpecificLineItems: (0, transactionCategorizationLocalDataHelper_1.mergeTabSpecificLineItems)(transactionLocalData.transactionReviewLocalData
-                            .tabSpecificLineItems, selectedTab, newTransactionLocalData.tabSpecificLineItems),
-                    },
-                    transactionId,
-                };
-                const selectedCheckBoxTransactionIds = draft.transactionCategorizationView[selectedTab]
-                    .selectedCheckBoxTransactionIds;
-                if (newTransactionLocalData.vendor != null &&
-                    newTransactionLocalData.vendor.id != null &&
-                    (0, transactionCategorizationLocalDataHelper_1.shouldAutoSelectAndAdd)(selectedTransaction, newTransactionLocalData, selectedCheckBoxTransactionIds, isAccountingClassesEnabled)) {
-                    draft.transactionCategorizationView[selectedTab].selectedCheckBoxTransactionIds = [
-                        ...selectedCheckBoxTransactionIds,
-                        transactionId,
-                    ];
-                }
-                // Mark transaction as dirty (vendor updated)
-                if (!draft.transactionCategorizationView[selectedTab].transactionIdsWithUnsavedData.includes(transactionId)) {
-                    draft.transactionCategorizationView[selectedTab].transactionIdsWithUnsavedData = [
-                        ...draft.transactionCategorizationView[selectedTab]
-                            .transactionIdsWithUnsavedData,
-                        transactionId,
-                    ];
-                }
-            }
-        },
-        updateSelectedTransactionId(draft, action) {
-            const { selectedTab, transactionId, lineId } = action.payload;
-            draft.transactionCategorizationView[selectedTab].selectedTransactionId =
-                transactionId;
-            draft.transactionCategorizationView[selectedTab].selectedTransactionLineId = lineId;
-        },
-        updateTransactionCategorizationSaveStatus: {
-            reducer(draft, action) {
-                const selectedTab = action.payload.selectedTab;
-                draft.transactionCategorizationView[selectedTab].saveStatus = {
-                    fetchState: action.payload.fetchState,
-                    error: action.payload.error,
-                };
-            },
-            prepare(selectedTab, fetchState, error) {
-                return {
-                    payload: {
-                        selectedTab,
-                        fetchState,
-                        error,
-                    },
-                };
-            },
-        },
-        markTransactionAsNotMiscategorized: {
-            reducer(draft, action) {
-                const selectedTab = action.payload.selectedTab;
-                draft.transactionCategorizationView[selectedTab].markAsNotMiscategorizedStatus = {
-                    fetchState: 'In-Progress',
-                    error: undefined,
-                };
-            },
-            prepare(selectedTab, transactionsInReview) {
-                return {
-                    payload: {
-                        selectedTab,
-                        transactionsInReview,
-                    },
-                };
-            },
-        },
-        updateStatusForTransactionNotMiscategorizedUpdateForCategorization: {
-            reducer(draft, action) {
-                const { selectedTab, selectedPeriod, uncheckTransactionIds, removeTransactionIdsFromSelectedPeriod, updateLineItemsByTransactionId, } = action.payload;
-                if (action.payload.fetchState === 'Completed') {
-                    const selectedCheckBoxTransactionIds = draft.transactionCategorizationView[selectedTab].selectedCheckBoxTransactionIds.filter((id) => !uncheckTransactionIds.includes(id));
-                    draft.transactionCategorizationView[selectedTab].selectedCheckBoxTransactionIds = [
-                        ...selectedCheckBoxTransactionIds,
-                    ];
-                    const transactionIdsBySelectedPeriod = draft.transactionCategorizationView[selectedTab]
-                        .transactionIdsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)];
-                    if (transactionIdsBySelectedPeriod != null) {
-                        draft.transactionCategorizationView[selectedTab].transactionIdsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] = transactionIdsBySelectedPeriod.filter((id) => !removeTransactionIdsFromSelectedPeriod.includes(id));
-                    }
-                    if (updateLineItemsByTransactionId != null) {
-                        Object.entries(updateLineItemsByTransactionId).forEach(([transactionId, lineIds]) => {
-                            if (lineIds.length > 0) {
-                                draft.transactionCategorizationView[selectedTab].transactionReviewLocalDataById[transactionId].transactionReviewLocalData.tabSpecificLineItems = {
-                                    ...draft.transactionCategorizationView[selectedTab]
-                                        .transactionReviewLocalDataById[transactionId]
-                                        .transactionReviewLocalData.tabSpecificLineItems,
-                                    [selectedTab]: [...lineIds],
-                                };
-                            }
-                            else {
-                                delete draft.transactionCategorizationView[selectedTab]
-                                    .transactionReviewLocalDataById[transactionId];
-                            }
-                        });
-                    }
-                    // Remove saved transaction IDs from dirty list
-                    draft.transactionCategorizationView[selectedTab].transactionIdsWithUnsavedData = draft.transactionCategorizationView[selectedTab].transactionIdsWithUnsavedData.filter((id) => !uncheckTransactionIds.includes(id));
-                }
-                draft.transactionCategorizationView[selectedTab].markAsNotMiscategorizedStatus = {
-                    fetchState: action.payload.fetchState,
-                    error: action.payload.error,
-                };
-            },
-            prepare(selectedTab, uncheckTransactionIds, removeTransactionIdsFromSelectedPeriod, selectedPeriod, fetchState, error, updateLineItemsByTransactionId) {
-                return {
-                    payload: {
-                        removeTransactionIdsFromSelectedPeriod,
-                        selectedPeriod,
-                        uncheckTransactionIds,
-                        selectedTab,
-                        fetchState,
-                        error,
-                        updateLineItemsByTransactionId,
-                    },
-                };
-            },
-        },
-        updateTotalCountForTransactionCategorization(draft, action) {
-            const { selectedTab, selectedPeriod, totalCount } = action.payload;
-            draft.transactionCategorizationView[selectedTab].uiState.totalCount[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] = totalCount;
-        },
-        updateParentTotalCountForTab(draft, action) {
-            const { selectedTab, selectedPeriod, parentTotalCount } = action.payload;
-            draft.parentTotalCountByTab[selectedTab][(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] = parentTotalCount;
-        },
-        updateSelectedCheckboxTransactionIds(draft, action) {
-            const selectedTab = action.payload.selectedTab;
-            const transactionIds = action.payload.transactionIds;
-            draft.transactionCategorizationView[selectedTab].selectedCheckBoxTransactionIds = [...transactionIds];
-        },
-        clearExpenseAutomationTransactionsViewPerTabView(draft, action) {
-            const selectedTab = action.payload;
-            draft.transactionCategorizationView[selectedTab] = {
-                ...exports.initialTransactionTabViewState,
-            };
-            draft.parentTotalCountByTab[selectedTab] = {};
-            // The per-sub-tab snapshot cache lives at the slice root and is
-            // exclusively populated by the autoCategorized tab's sub-tab switching
-            // (see updateTransactionCategorizationCompletedSubTab). When that tab
-            // is reset, leaving stale snapshots behind would short-circuit the
-            // next sub-tab visit with phantom row IDs / page tokens that no longer
-            // correspond to anything in state — drop them in lockstep.
-            if (selectedTab === 'autoCategorized') {
-                draft.autoCategorizedSubTabCache = {};
-            }
-        },
-        clearExpenseAutomationTransactionsView(draft) {
-            Object.assign(draft, exports.initialState);
-        },
-        updateTransactionCategorizationUploadReceiptState: {
-            reducer(draft, action) {
-                const { transactionId, fetchStatus, selectedTab } = action.payload;
-                draft.transactionCategorizationView[selectedTab].uploadReceiptStatusById[transactionId] = fetchStatus;
-            },
-            prepare(selectedTab, transactionId, fetchStatus) {
-                return { payload: { selectedTab, transactionId, fetchStatus } };
-            },
-        },
-        uploadTransactionCategorizationReceiptSuccess: {
-            reducer(draft, action) {
-                const { transactionPayload, selectedTab } = action.payload;
-                draft.transactionCategorizationView[selectedTab].uploadReceiptStatusById[transactionPayload.transaction_id] = {
-                    fetchState: 'Completed',
-                    error: undefined,
-                };
-            },
-            prepare(selectedTab, transactionPayload, updateType = 'merge') {
-                return { payload: { selectedTab, transactionPayload, updateType } };
-            },
-        },
-        syncTransactionCategorizationFromDetailSave: {
-            prepare(transactionId, updatedTransaction, pendingReviewLineIds) {
-                return {
-                    payload: {
-                        transactionId,
-                        updatedTransaction,
-                        pendingReviewLineIds,
-                    },
-                };
-            },
-            reducer(draft, action) {
-                const { transactionId, updatedTransaction, pendingReviewLineIds } = action.payload;
-                const txnId = transactionId.id;
-                const reviewTabView = draft.transactionCategorizationView.review;
-                const autoTabView = draft.transactionCategorizationView.autoCategorized;
-                const existsInReview = reviewTabView.transactionReviewLocalDataById[txnId] != null;
-                const existsInAuto = autoTabView.transactionReviewLocalDataById[txnId] != null;
-                if (!existsInReview && !existsInAuto) {
-                    return;
-                }
-                // Auto tab: retain only lines still auto_reviewed or auto_categorized
-                if (existsInAuto) {
-                    (0, transactionCategorizationLocalDataHelper_1.filterAutoTabLineItems)(autoTabView, txnId, updatedTransaction);
-                }
-                const allReviewed = pendingReviewLineIds.length === 0;
-                if (allReviewed) {
-                    if (existsInReview) {
-                        (0, transactionCategorizationLocalDataHelper_1.removeTransactionFromTabView)(reviewTabView, txnId);
-                    }
-                    return;
-                }
-                // Partially reviewed: rebuild review tab local data with pending review lines
-                if (existsInReview) {
-                    const newLocalData = (0, transactionCategorizationLocalDataHelper_1.toTransactionDetailLocalData)(updatedTransaction, 'review', pendingReviewLineIds);
-                    reviewTabView.transactionReviewLocalDataById[txnId] = {
-                        transactionId: txnId,
-                        transactionReviewLocalData: {
-                            ...newLocalData,
-                            sortedLineItems: updatedTransaction.lines?.map((l) => l.id) ?? [],
-                            tabSpecificLineItems: {
-                                review: pendingReviewLineIds,
-                            },
-                        },
-                    };
-                    reviewTabView.selectedCheckBoxTransactionIds =
-                        reviewTabView.selectedCheckBoxTransactionIds.filter((id) => id !== txnId);
-                    reviewTabView.transactionIdsWithUnsavedData =
-                        reviewTabView.transactionIdsWithUnsavedData.filter((id) => id !== txnId);
-                }
-            },
-        },
-        backgroundRefetchReviewTab: {
-            prepare(period) {
-                return {
-                    payload: {
-                        period,
-                    },
-                };
-            },
-            reducer(draft) {
-                draft.transactionCategorizationView.review.refreshStatus = {
-                    fetchState: 'In-Progress',
-                    error: undefined,
-                };
-            },
-        },
-        removeTransactionFromAllTabs: {
-            prepare(transactionId) {
-                return { payload: { transactionId } };
-            },
-            reducer(draft, action) {
-                const { transactionId } = action.payload;
-                for (const tab of transactionsViewState_1.TRANSACTIONS_TABS) {
-                    (0, transactionCategorizationLocalDataHelper_1.removeTransactionFromTabView)(draft.transactionCategorizationView[tab], transactionId);
-                }
-            },
-        },
-    },
-    extraReducers: (builder) => {
-        builder.addCase(rootActions_1.clearAll, (draft) => {
-            Object.assign(draft, exports.initialState);
-        });
-    },
-});
-_a = expenseAutomationTransactionsView.actions, exports.fetchTransactionCategorization = _a.fetchTransactionCategorization, exports.updateTransactionCategorizationUIState = _a.updateTransactionCategorizationUIState, exports.updateTransactionFilters = _a.updateTransactionFilters, exports.initializeTransactionCategorizationViewLocalData = _a.initializeTransactionCategorizationViewLocalData, exports.saveTransactionCategorizationLocalData = _a.saveTransactionCategorizationLocalData, exports.fetchTransactionCategorizationFailure = _a.fetchTransactionCategorizationFailure, exports.saveTransactionCategorization = _a.saveTransactionCategorization, exports.updateTransactionCategorization = _a.updateTransactionCategorization, exports.updateCurrentSelectedTransactionCategorizationTab = _a.updateCurrentSelectedTransactionCategorizationTab, exports.updateTransactionCategorizationCompletedSubTab = _a.updateTransactionCategorizationCompletedSubTab, exports.updateTransactionGroup = _a.updateTransactionGroup, exports.updateTransactionCategorizationSaveStatus = _a.updateTransactionCategorizationSaveStatus, exports.markTransactionAsNotMiscategorized = _a.markTransactionAsNotMiscategorized, exports.updateStatusForTransactionNotMiscategorizedUpdateForCategorization = _a.updateStatusForTransactionNotMiscategorizedUpdateForCategorization, exports.updateSelectedVendorForTransaction = _a.updateSelectedVendorForTransaction, exports.updateSelectedCustomerForTransaction = _a.updateSelectedCustomerForTransaction, exports.setAllItemsToCategoryClassInLocalDataForCategorization = _a.setAllItemsToCategoryClassInLocalDataForCategorization, exports.updateTotalCountForTransactionCategorization = _a.updateTotalCountForTransactionCategorization, exports.updateParentTotalCountForTab = _a.updateParentTotalCountForTab, exports.fetchTransactionCategorizationSuccess = _a.fetchTransactionCategorizationSuccess, exports.resetOtherTabsFetchState = _a.resetOtherTabsFetchState, exports.fetchTransactionCategorizationView = _a.fetchTransactionCategorizationView, exports.updateSelectedCheckboxTransactionIds = _a.updateSelectedCheckboxTransactionIds, exports.clearExpenseAutomationTransactionsViewPerTabView = _a.clearExpenseAutomationTransactionsViewPerTabView, exports.clearExpenseAutomationTransactionsView = _a.clearExpenseAutomationTransactionsView, exports.setEntityRecommendationForLineIdsForCategorization = _a.setEntityRecommendationForLineIdsForCategorization, exports.markCategoryClassRecommendationsInProgressForCategorization = _a.markCategoryClassRecommendationsInProgressForCategorization, exports.markCategoryClassRecommendationsCompletedForCategorization = _a.markCategoryClassRecommendationsCompletedForCategorization, exports.markCategoryClassRecommendationsFailureForCategorization = _a.markCategoryClassRecommendationsFailureForCategorization, exports.updateSelectedTransactionId = _a.updateSelectedTransactionId, exports.syncTransactionCategorizationFromDetailSave = _a.syncTransactionCategorizationFromDetailSave, exports.backgroundRefetchReviewTab = _a.backgroundRefetchReviewTab, exports.removeTransactionFromAllTabs = _a.removeTransactionFromAllTabs, exports.updateTransactionCategorizationUploadReceiptState = _a.updateTransactionCategorizationUploadReceiptState, exports.uploadTransactionCategorizationReceiptSuccess = _a.uploadTransactionCategorizationReceiptSuccess;
-exports.default = expenseAutomationTransactionsView.reducer;