@zeniai/client-epic-state 5.0.55-betaAR4 → 5.0.55-betaAR6

package/lib/view/expenseAutomationView/reducers/transactionsViewReducer.d.ts

@@ -14,7 +14,7 @@ import { ZeniAPIStatus } from '../../../responsePayload';
 import { UncategorizedAccounts } from '../../accountList/accountListSelector';
 import { UpdateTransactionCategorizationResponsePayload } from '../payload/transactionCategorizationPayload';
 import { SupportedTransactionCategorization, TransactionSaveUpdates, TransactionsTab, TransactionsTabViewState, TransactionsViewState, TransactionsViewUIState } from '../types/transactionsViewState';
-import { TransactionFilters } from '../../spendManagement/spendManagementFilterHelpers';
+import { TransactionFilters } from '../transactionFilterHelpers';
 export declare const initialTransactionTabViewState: TransactionsTabViewState;
 export declare const initialState: TransactionsViewState;
 export declare const fetchTransactionCategorization: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[selectedTab: "review" | "autoCategorized", period: TimePeriod, cacheOverride?: any, keepExistingListItems?: any, searchString?: string | undefined, pageToken?: PageToken | undefined, refreshViewInBackground?: any, resetListItems?: boolean | undefined, isUncategorizedExpenseCategoryEnabled?: boolean | undefined], {

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

@@ -1,6 +1,6 @@
 import { TransactionWithCOT } from '../../../entity/transaction/stateTypes/transaction';
 import { RootState } from '../../../reducer';
-import { TransactionView } from '../../spendManagement/spendManagementFilterHelpers';
+import { TransactionView } from '../transactionFilterHelpers';
 import { ExpenseAutomationTransactionViewSelector, TransactionReviewLocalDataSelectorView } from '../selectorTypes/transactionsViewSelectorTypes';
 export declare const toTransactionView: (transaction: TransactionWithCOT, transactionLocalData?: TransactionReviewLocalDataSelectorView) => TransactionView;
 export declare function getExpenseAutomationTransactionView(state: RootState): ExpenseAutomationTransactionViewSelector;

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

@@ -11,7 +11,7 @@ const timePeriod_1 = require("../../../commonStateTypes/timePeriod");
 const tenantSelector_1 = require("../../../entity/tenant/tenantSelector");
 const transactionHelper_1 = require("../../../entity/transaction/transactionHelper");
 const transactionSelector_1 = require("../../../entity/transaction/transactionSelector");
-const spendManagementFilterHelpers_1 = require("../../spendManagement/spendManagementFilterHelpers");
+const transactionFilterHelpers_1 = require("../transactionFilterHelpers");
 const accountListSelector_1 = require("../../accountList/accountListSelector");
 const classListSelector_1 = require("../../classList/classListSelector");
 const projectListSelector_1 = require("../../projectList/projectListSelector");
@@ -74,8 +74,9 @@ function getExpenseAutomationTransactionView(state) {
         const localData = transactionLocalDataMap.get(transaction.id);
         return (0, exports.toTransactionView)(transaction, localData);
     });
-    // Apply advanced filters if they exist
-    const filteredTransactionViews = (0, spendManagementFilterHelpers_1.applyAdvancedFiltersOnList)('transaction_categorization', transactionViews, filters);
+    // Apply TC-specific filters (lives under expenseAutomationView, independent
+    // of the Spend Management filter pipeline).
+    const filteredTransactionViews = (0, transactionFilterHelpers_1.applyTransactionFilters)(transactionViews, filters);
     // Convert back to TransactionWithCOT for return
     const filteredTransactionsWithCOT = filteredTransactionViews.map((view) => view.transaction);
     // Get transactionLocalData for filtered transactions

package/lib/view/expenseAutomationView/transactionFilterHelpers.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Filter machinery for the Transaction Categorization feature inside
+ * Expense Automation. Intentionally self-contained — does NOT import anything
+ * from `view/spendManagement/*`, because Transaction Categorization is not a
+ * Spend Management product. Generic primitives (`CategoryCombinationOperator`,
+ * `FilterCategoryType`) are redeclared locally rather than imported across the
+ * feature boundary; their definitions happen to coincide with the
+ * spend-management equivalents, which is fine — they're the same primitive
+ * concept used independently by both feature groups.
+ */
+import { Amount } from '../../commonStateTypes/amount';
+import { ID } from '../../commonStateTypes/common';
+import { TransactionType } from '../../entity/transaction/stateTypes/transactionType';
+import { SupportedTransactionWithCOT } from '../../entity/transaction/transactionState';
+import { TransactionReviewLocalDataSelectorView } from './selectorTypes/transactionsViewSelectorTypes';
+/** Local copy of the generic combination operator — independent of SM. */
+export type CategoryCombinationOperator = 'AND' | 'OR';
+/** Local copy of the generic filter category-input type — independent of SM. */
+export type FilterCategoryType = 'searchAutocomplete' | 'user' | 'dateRange' | 'numberRange' | 'dropdown';
+export type TransactionFilterEntityType = 'transaction_categorization' | 'customer' | 'vendor' | 'merchant';
+export type TransactionFilterCategoryField = 'payment_account_name' | 'payment_account_type' | 'payee' | 'category' | 'class' | 'amount';
+export interface TransactionFilterCategoryDropdownOption {
+    value: TransactionFilterCategoryField;
+    multiple?: boolean;
+    type?: FilterCategoryType;
+}
+export declare const TRANSACTION_FILTER_CATEGORIES: TransactionFilterCategoryDropdownOption[];
+/** Amount filter operators for transaction_categorization. */
+export type TransactionFilterAmountMatchingOperator = 'equal' | 'not-equal' | 'lessThan' | 'greaterThan' | 'inBetween';
+export interface TransactionFilterCategory {
+    field: TransactionFilterCategoryField;
+    matchingOperator: TransactionFilterAmountMatchingOperator;
+    values: (string | number)[];
+    valuesCombinationOperator: 'ANY';
+}
+export interface TransactionFilters {
+    categories: TransactionFilterCategory[];
+    categoryCombinationOperator: CategoryCombinationOperator;
+}
+export interface TransactionView {
+    amount: Amount;
+    createTime: import('../../zeniDayJS').ZeniDate;
+    date: import('../../zeniDayJS').ZeniDate;
+    description: string;
+    id: ID;
+    memo: string;
+    transaction: SupportedTransactionWithCOT;
+    type: TransactionType;
+    customerId?: ID;
+    customerName?: string;
+    transactionLocalData?: TransactionReviewLocalDataSelectorView;
+    typeName?: string;
+    vendorId?: ID;
+    vendorName?: string;
+}
+/**
+ * TC-only equivalent of `applyAdvancedFiltersOnList`. Filters a list of
+ * `TransactionView` items against a `TransactionFilters` object using the
+ * AND/OR combination semantics from `categoryCombinationOperator`.
+ *
+ * Independent of `view/spendManagement` — keeps the TC filter pipeline cleanly
+ * inside the Expense Automation feature group.
+ */
+export declare const applyTransactionFilters: (transactions: TransactionView[], filters?: TransactionFilters) => TransactionView[];

package/lib/view/expenseAutomationView/transactionFilterHelpers.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyTransactionFilters = exports.TRANSACTION_FILTER_CATEGORIES = void 0;
+exports.TRANSACTION_FILTER_CATEGORIES = [
+    { value: 'payment_account_name', type: 'dropdown' },
+    { value: 'payment_account_type', type: 'dropdown' },
+    { value: 'payee', type: 'searchAutocomplete' },
+    { value: 'category', type: 'dropdown' },
+    { value: 'class', type: 'dropdown' },
+    { value: 'amount', type: 'numberRange' },
+];
+/**
+ * Resolve the comparable value for a transaction against a given filter field.
+ * Returns undefined when the transaction doesn't carry the field — callers
+ * decide whether absence counts as a match (for 'not-equal' it does).
+ */
+const getCategoryValueForTransaction = (key, transaction) => {
+    switch (key) {
+        case 'amount': {
+            // Prefer transactionLocalData line items (sum). Fall back to lines on
+            // the transaction itself. Final fallback: transaction-level amount.
+            const localDataForAmount = transaction.transactionLocalData?.transactionReviewLocalData;
+            if (localDataForAmount?.lineItemById) {
+                const lineItems = Object.values(localDataForAmount.lineItemById);
+                if (lineItems.length > 0) {
+                    return lineItems.reduce((sum, lineItem) => sum + (lineItem.amount?.amount ?? 0), 0);
+                }
+            }
+            if (transaction.transaction.lines &&
+                transaction.transaction.lines.length > 0) {
+                return transaction.transaction.lines.reduce((sum, line) => sum + (line.amount?.amount ?? 0), 0);
+            }
+            return transaction.amount.amount;
+        }
+        case 'payee': {
+            if (transaction.vendorName) {
+                return transaction.vendorName;
+            }
+            if (transaction.customerName) {
+                return transaction.customerName;
+            }
+            const localData = transaction.transactionLocalData?.transactionReviewLocalData;
+            if (localData?.vendor?.name) {
+                return localData.vendor.name;
+            }
+            if (localData?.customer?.name) {
+                return localData.customer.name;
+            }
+            return undefined;
+        }
+        case 'payment_account_name': {
+            // Match what TransactionCategorizationListRow renders for the cell.
+            return transaction.transaction.account?.accountName;
+        }
+        case 'payment_account_type': {
+            // Raw `paymentType` enum ("credit_card" / "check" / "cash"). Dropdown
+            // option values use the same enum; row uses `paymentTypeName` for the
+            // human label.
+            return transaction.transaction.paymentType;
+        }
+        case 'category': {
+            const localDataForCategory = transaction.transactionLocalData?.transactionReviewLocalData;
+            if (localDataForCategory) {
+                const firstLineItem = Object.values(localDataForCategory.lineItemById)[0];
+                if (firstLineItem?.account?.accountId) {
+                    return firstLineItem.account.accountId;
+                }
+                if (firstLineItem?.account?.qboId) {
+                    return firstLineItem.account.qboId;
+                }
+                if (firstLineItem?.account?.accountName) {
+                    return firstLineItem.account.accountName;
+                }
+            }
+            const firstLineForCategory = transaction.transaction.lines?.[0];
+            if (firstLineForCategory?.type ===
+                'transaction_with_account_and_class_line' ||
+                firstLineForCategory?.type ===
+                    'transaction_with_product_or_service_line' ||
+                firstLineForCategory?.type === 'journal_entry_transaction_line') {
+                const account = firstLineForCategory.account;
+                return account?.accountId ?? account?.qboId ?? account?.accountName;
+            }
+            return undefined;
+        }
+        case 'class': {
+            const localDataForClass = transaction.transactionLocalData?.transactionReviewLocalData;
+            if (localDataForClass) {
+                const firstLineItemForClass = Object.values(localDataForClass.lineItemById)[0];
+                if (firstLineItemForClass?.class?.classId) {
+                    return firstLineItemForClass.class.classId;
+                }
+                if (firstLineItemForClass?.class?.qboId) {
+                    return firstLineItemForClass.class.qboId;
+                }
+                if (firstLineItemForClass?.class?.className) {
+                    return firstLineItemForClass.class.className;
+                }
+            }
+            const firstLineForClass = transaction.transaction.lines?.[0];
+            if (firstLineForClass?.type === 'transaction_with_account_and_class_line' ||
+                firstLineForClass?.type ===
+                    'transaction_with_product_or_service_line' ||
+                firstLineForClass?.type === 'journal_entry_transaction_line') {
+                const classData = firstLineForClass.class;
+                return classData?.classId ?? classData?.qboId ?? classData?.className;
+            }
+            return undefined;
+        }
+        default:
+            return undefined;
+    }
+};
+/**
+ * TC-only amount matcher. Supports all five operators TC defines, including
+ * the legacy "1000<->5000" range-string form (kept for backward compatibility
+ * with persisted filter state that may still contain that encoding).
+ */
+const matchAmount = (amount, category) => {
+    const op = category.matchingOperator;
+    const values = category.values;
+    let matched = false;
+    if (op === 'inBetween') {
+        if (values.length >= 2) {
+            const min = Number(values[0]);
+            const max = Number(values[1]);
+            matched = amount >= min && amount <= max;
+        }
+    }
+    else if (op === 'lessThan') {
+        if (values.length >= 1) {
+            matched = amount < Number(values[0]);
+        }
+    }
+    else if (op === 'greaterThan') {
+        if (values.length >= 1) {
+            matched = amount > Number(values[0]);
+        }
+    }
+    else if (op === 'equal' &&
+        values.length === 1 &&
+        String(values[0]).includes('<->')) {
+        // Backward compatibility: ["1000<->5000"] with matchingOperator "equal".
+        const parts = String(values[0]).split('<->');
+        matched =
+            amount >= Number(parts[0] ?? '') && amount <= Number(parts[1] ?? '');
+    }
+    else if (op === 'equal' && values.length === 1) {
+        matched = amount === Number(values[0]);
+    }
+    return op === 'not-equal' ? !matched : matched;
+};
+const transactionMatchesCategory = (transaction, category) => {
+    const value = getCategoryValueForTransaction(category.field, transaction);
+    if (value == null) {
+        // Absent values count as a match only under 'not-equal'.
+        return category.matchingOperator === 'not-equal';
+    }
+    if (category.field === 'amount') {
+        return matchAmount(Number(value), category);
+    }
+    const valueStr = value.toString();
+    const valueInList = category.values.some((v) => v.toString() === valueStr);
+    return category.matchingOperator === 'not-equal' ? !valueInList : valueInList;
+};
+/**
+ * TC-only equivalent of `applyAdvancedFiltersOnList`. Filters a list of
+ * `TransactionView` items against a `TransactionFilters` object using the
+ * AND/OR combination semantics from `categoryCombinationOperator`.
+ *
+ * Independent of `view/spendManagement` — keeps the TC filter pipeline cleanly
+ * inside the Expense Automation feature group.
+ */
+const applyTransactionFilters = (transactions, filters) => {
+    if (filters?.categories == null || filters.categories.length === 0) {
+        return transactions;
+    }
+    const activeCategories = filters.categories.filter((c) => c.field != null && c.values.length > 0);
+    if (activeCategories.length === 0) {
+        return transactions;
+    }
+    const op = filters.categoryCombinationOperator;
+    return transactions.filter((txn) => {
+        if (op === 'AND') {
+            return activeCategories.every((cat) => transactionMatchesCategory(txn, cat));
+        }
+        return activeCategories.some((cat) => transactionMatchesCategory(txn, cat));
+    });
+};
+exports.applyTransactionFilters = applyTransactionFilters;

package/lib/view/expenseAutomationView/types/transactionsViewState.d.ts

@@ -15,7 +15,7 @@ import { TransactionCategory, TransactionType } from '../../../entity/transactio
 import { VendorBase } from '../../../entity/vendor/vendorState';
 import { ZeniDate } from '../../../zeniDayJS';
 import { EntityRecommendationKey } from '../../recommendation/recommendationState';
-import { TransactionFilters } from '../../spendManagement/spendManagementFilterHelpers';
+import { TransactionFilters } from '../transactionFilterHelpers';
 import { TransactionDetailKey } from '../../transactionDetail/transactionDetailState';
 export declare const toTransactionsSortKey: (v: string) => "date" | "amount" | "vendor" | "project" | "category" | "class" | "payment_account" | "transaction_type" | "memo_and_receipt";
 export type TransactionsSortKey = ReturnType<typeof toTransactionsSortKey>;

package/lib/view/spendManagement/spendManagementFilterHelpers.d.ts

@@ -1,12 +1,7 @@
-import { Amount } from '../../commonStateTypes/amount';
-import { ID } from '../../commonStateTypes/common';
 import { TimePeriod } from '../../commonStateTypes/timePeriod';
-import { TransactionType } from '../../entity/transaction/stateTypes/transactionType';
-import { SupportedTransactionWithCOT } from '../../entity/transaction/transactionState';
 import { UserRoleType } from '../../entity/userRole/userRoleType';
 import { RootState } from '../../reducer';
 import { ZeniDate } from '../../zeniDayJS';
-import { TransactionReviewLocalDataSelectorView } from '../expenseAutomationView/selectorTypes/transactionsViewSelectorTypes';
 import { TaskListFilterCategoryField, TaskListFilters } from '../taskManager/taskListView/taskList';
 import { TaskWithUserDetails } from '../taskManager/taskListView/taskListSelector';
 import { BillTransactionView } from './billPay/billList/billListSelector';
@@ -15,8 +10,8 @@ import { PaymentHistoryFilterCategoryDropdownOption, PaymentHistoryFilters } fro
 import { ChargeCardRepaymentWithUser } from './chargeCards/chargeCardPaymentHistory/chargeCardPaymentHistorySelector';
 import { ReimbursementView } from './reimbursement/remiListView/remiListSelector';
 import { ReimbursementFilters, RemiListViewFilterCategoryField } from './reimbursement/remiListView/remiListState';
-export type SpendManagementFiltersType = BillPayFilters | ReimbursementFilters | TaskListFilters | TransactionFilters | PaymentHistoryFilters;
-export type SpendManagementFilterEntityType = 'bill_pay' | 'reimbursement' | 'task_management' | 'transaction_categorization' | 'charge_card_payment_history';
+export type SpendManagementFiltersType = BillPayFilters | ReimbursementFilters | TaskListFilters | PaymentHistoryFilters;
+export type SpendManagementFilterEntityType = 'bill_pay' | 'reimbursement' | 'task_management' | 'charge_card_payment_history';
 export type FilterCategoryType = 'searchAutocomplete' | 'user' | 'dateRange' | 'numberRange' | 'dropdown';
 export interface MatchingOperatorDropdownOption {
     label: 'is' | 'is not';
@@ -38,45 +33,9 @@ export interface TaskFilterCategoryDropdownOption {
     multiple?: boolean;
     type?: FilterCategoryType;
 }
-export type SpendManagementFilterCategoryDropdownOption = BillPayFilterCategoryDropdownOption | ReimbursementFilterCategoryDropdownOption | TaskFilterCategoryDropdownOption | TransactionFilterCategoryDropdownOption | PaymentHistoryFilterCategoryDropdownOption;
-export interface TransactionFilterCategoryDropdownOption {
-    value: TransactionFilterCategoryField;
-    multiple?: boolean;
-    type?: FilterCategoryType;
-}
-export type TransactionFilterEntityType = 'transaction_categorization' | 'customer' | 'vendor' | 'merchant';
-export type TransactionFilterCategoryField = 'payment_account_name' | 'payment_account_type' | 'payee' | 'category' | 'class' | 'amount';
-export declare const TRANSACTION_FILTER_CATEGORIES: TransactionFilterCategoryDropdownOption[];
-export interface TransactionFilters {
-    categories: TransactionFilterCategory[];
-    categoryCombinationOperator: CategoryCombinationOperator;
-}
-/** Amount filter operators for transaction_categorization (expense automation). Other entities use only equal/not-equal. */
-export type TransactionFilterAmountMatchingOperator = 'equal' | 'not-equal' | 'lessThan' | 'greaterThan' | 'inBetween';
-export interface TransactionFilterCategory {
-    field: TransactionFilterCategoryField;
-    matchingOperator: TransactionFilterAmountMatchingOperator;
-    values: (string | ZeniDate)[];
-    valuesCombinationOperator: 'ANY';
-}
-export interface TransactionView {
-    amount: Amount;
-    createTime: ZeniDate;
-    date: ZeniDate;
-    description: string;
-    id: ID;
-    memo: string;
-    transaction: SupportedTransactionWithCOT;
-    type: TransactionType;
-    customerId?: ID;
-    customerName?: string;
-    transactionLocalData?: TransactionReviewLocalDataSelectorView;
-    typeName?: string;
-    vendorId?: ID;
-    vendorName?: string;
-}
+export type SpendManagementFilterCategoryDropdownOption = BillPayFilterCategoryDropdownOption | ReimbursementFilterCategoryDropdownOption | TaskFilterCategoryDropdownOption | PaymentHistoryFilterCategoryDropdownOption;
 export type FilterCategoryValueType = string | number | ZeniDate;
-export declare const applyAdvancedFiltersOnList: (entity: SpendManagementFilterEntityType, allItems: BillTransactionView[] | ReimbursementView[] | TaskWithUserDetails[] | TransactionView[] | ChargeCardRepaymentWithUser[], filters?: BillPayFilters | ReimbursementFilters | TaskListFilters | TransactionFilters | PaymentHistoryFilters, filteredItems?: (BillTransactionView | ReimbursementView | TaskWithUserDetails | TransactionView | ChargeCardRepaymentWithUser)[], index?: number) => (BillTransactionView | ReimbursementView | TaskWithUserDetails | TransactionView | ChargeCardRepaymentWithUser)[];
+export declare const applyAdvancedFiltersOnList: (entity: SpendManagementFilterEntityType, allItems: BillTransactionView[] | ReimbursementView[] | TaskWithUserDetails[] | ChargeCardRepaymentWithUser[], filters?: BillPayFilters | ReimbursementFilters | TaskListFilters | PaymentHistoryFilters, filteredItems?: (BillTransactionView | ReimbursementView | TaskWithUserDetails | ChargeCardRepaymentWithUser)[], index?: number) => (BillTransactionView | ReimbursementView | TaskWithUserDetails | ChargeCardRepaymentWithUser)[];
 export declare const isBillListDownloadable: (state: RootState, currentTimePeriod: TimePeriod) => boolean;
 export declare const isRemiListDownloadable: (state: RootState, currentTimePeriod: TimePeriod) => boolean;
 export declare const hideCreatedByFilter: (userRole: UserRoleType[]) => boolean;

package/lib/view/spendManagement/spendManagementFilterHelpers.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hideCreatedByFilter = exports.isRemiListDownloadable = exports.isBillListDownloadable = exports.applyAdvancedFiltersOnList = exports.TRANSACTION_FILTER_CATEGORIES = void 0;
+exports.hideCreatedByFilter = exports.isRemiListDownloadable = exports.isBillListDownloadable = exports.applyAdvancedFiltersOnList = void 0;
 const get_1 = __importDefault(require("lodash/get"));
 const userSelector_1 = require("../../entity/user/userSelector");
 const userRoleType_1 = require("../../entity/userRole/userRoleType");
@@ -13,81 +13,30 @@ const billListState_1 = require("./billPay/billList/billListState");
 const helpers_1 = require("./helpers");
 const remiListSelector_1 = require("./reimbursement/remiListView/remiListSelector");
 const remiListState_1 = require("./reimbursement/remiListView/remiListState");
-exports.TRANSACTION_FILTER_CATEGORIES = [
-    { value: 'payment_account_name', type: 'dropdown' },
-    { value: 'payment_account_type', type: 'dropdown' },
-    { value: 'payee', type: 'searchAutocomplete' },
-    { value: 'category', type: 'dropdown' },
-    { value: 'class', type: 'dropdown' },
-    { value: 'amount', type: 'numberRange' },
-];
 //filters items against filter values representing a range. ex: date (from-to), amount(1k<-->5k)
-// For amount: supports new transaction_categorization operators (inBetween, lessThan, greaterThan) and
-// backward compatibility for old format values: ["1000<->5000"] with matchingOperator "equal".
-// Other entities (bill_pay, reimbursement, etc.) use only equal/not-equal and are unchanged.
+// Spend Management uses only equal/not-equal — TC amount operators
+// (inBetween, lessThan, greaterThan) live in the TC filter pipeline.
 const filterItemOnRangeCategoryType = (valueForItem, currentFilter) => {
     let doesItemFallInValueRange = false;
     const filterField = currentFilter.field;
     if (filterField === 'amount') {
-        const currentValue = Number(valueForItem);
-        const op = currentFilter.matchingOperator;
-        const values = currentFilter.values;
-        if (op === 'inBetween') {
-            // New format: values = [min, max] (expense automation transaction_categorization only)
-            if (values.length >= 2) {
-                const min = Number(values[0]);
-                const max = Number(values[1]);
-                doesItemFallInValueRange = currentValue >= min && currentValue <= max;
-            }
-        }
-        else if (op === 'lessThan') {
-            if (values.length >= 1) {
-                const threshold = Number(values[0]);
-                doesItemFallInValueRange = currentValue < threshold;
-            }
-        }
-        else if (op === 'greaterThan') {
-            if (values.length >= 1) {
-                const threshold = Number(values[0]);
-                doesItemFallInValueRange = currentValue > threshold;
-            }
-        }
-        else if (op === 'equal' &&
-            values.length === 1 &&
-            String(values[0]).includes('<->')) {
-            // Backward compatibility: old format ["1000<->5000"] with matchingOperator "equal"
-            const parts = String(values[0]).split('<->');
-            const lowerValue = Number(parts[0] ?? '');
-            const higherValue = Number(parts[1] ?? '');
-            doesItemFallInValueRange =
-                currentValue >= lowerValue && currentValue <= higherValue;
-        }
-        else if (op === 'equal' && values.length === 1) {
-            // New format: exact match on single value (expense automation)
-            const val = Number(values[0]);
-            doesItemFallInValueRange = currentValue === val;
-        }
-        else {
-            // Existing logic for equal/not-equal (bill_pay, reimbursement, etc. or multiple range values)
-            for (const filterValue of values) {
-                const lowerValue = Number.parseInt(filterValue?.toString()?.split('<->')[0] ?? '', 10);
-                const higherValue = Number.parseInt(filterValue?.toString()?.split('<->')[1] ?? '', 10);
-                if (currentValue >= lowerValue && currentValue <= higherValue) {
-                    doesItemFallInValueRange = true;
-                }
+        for (const filterValue of currentFilter.values) {
+            const currentValue = parseInt(valueForItem.toString());
+            const lowerValue = parseInt(filterValue?.toString()?.split('<->')[0] ?? '');
+            const higherValue = parseInt(filterValue?.toString()?.split('<->')[1] ?? '');
+            if (currentValue >= lowerValue && currentValue <= higherValue) {
+                doesItemFallInValueRange = true;
             }
         }
-        return op === 'not-equal'
-            ? !doesItemFallInValueRange
-            : doesItemFallInValueRange;
     }
-    // Date range and other range fields (unchanged for other entities)
-    const currentValue = valueForItem;
-    const lowerValue = currentFilter.values[0];
-    const higherValue = currentFilter.values[1];
-    if (currentValue.isSameOrAfter(lowerValue) &&
-        currentValue.isSameOrBefore(higherValue)) {
-        doesItemFallInValueRange = true;
+    else {
+        const currentValue = valueForItem;
+        const lowerValue = currentFilter.values[0];
+        const higherValue = currentFilter.values[1];
+        if (currentValue.isSameOrAfter(lowerValue) &&
+            currentValue.isSameOrBefore(higherValue)) {
+            doesItemFallInValueRange = true;
+        }
     }
     return currentFilter.matchingOperator === 'equal'
         ? doesItemFallInValueRange
@@ -172,11 +121,7 @@ const applyAdvancedFiltersOnList = (entity, allItems, filters, filteredItems = [
                 ? getCategoryValueForReimbursement(key, item)
                 : entity === 'task_management'
                     ? getCategoryValueForTaskList(key, item)
-                    : entity === 'transaction_categorization'
-                        ? getCategoryValueForTransaction(key, item)
-                        : entity === 'charge_card_payment_history'
-                            ? getCategoryValueForPaymentHistory(key, item)
-                            : undefined;
+                    : getCategoryValueForPaymentHistory(key, item);
         if (categoryValue == null) {
             if (currentFilter.matchingOperator === 'not-equal') {
                 return true;
@@ -298,119 +243,6 @@ const getCategoryValueForReimbursement = (key, reimbursement) => {
             return undefined;
     }
 };
-const getCategoryValueForTransaction = (key, transaction) => {
-    switch (key) {
-        case 'amount': {
-            // Get from transactionLocalData line items (preferred) - sum all line item amounts
-            const localDataForAmount = transaction.transactionLocalData?.transactionReviewLocalData;
-            if (localDataForAmount?.lineItemById) {
-                const lineItems = Object.values(localDataForAmount.lineItemById);
-                if (lineItems.length > 0) {
-                    // Sum all line item amounts
-                    const totalAmount = lineItems.reduce((sum, lineItem) => sum + (lineItem.amount?.amount ?? 0), 0);
-                    return totalAmount;
-                }
-            }
-            // Fallback to transaction-level amount or sum from transaction lines
-            if (transaction.transaction.lines &&
-                transaction.transaction.lines.length > 0) {
-                const totalAmount = transaction.transaction.lines.reduce((sum, line) => sum + (line.amount?.amount ?? 0), 0);
-                return totalAmount;
-            }
-            // Final fallback to transaction amount
-            return transaction.amount.amount;
-        }
-        case 'payee': {
-            // Priority: vendorName > customerName > from transactionLocalData
-            if (transaction.vendorName) {
-                return transaction.vendorName;
-            }
-            if (transaction.customerName) {
-                return transaction.customerName;
-            }
-            // Check transactionLocalData for vendor/customer
-            const localData = transaction.transactionLocalData?.transactionReviewLocalData;
-            if (localData?.vendor?.name) {
-                return localData.vendor.name;
-            }
-            if (localData?.customer?.name) {
-                return localData.customer.name;
-            }
-            return undefined;
-        }
-        case 'payment_account_name': {
-            // Match the value the row renders: TransactionCategorizationListRow reads
-            // `currentTransaction?.account?.accountName` for the Payment Account Name
-            // column. Returning the same field here keeps filter-match parity with the
-            // visible cell, so any row a user can see is also a row the filter can match.
-            return transaction.transaction.account?.accountName;
-        }
-        case 'payment_account_type': {
-            // Compare against the raw `paymentType` enum (e.g. "credit_card", "check",
-            // "cash"). The same enum is what TransactionCategorizationListRow uses for
-            // its icon switch on line ~1675, and it's what the dropdown options emit
-            // as `value`. Display labels come from each account's `paymentTypeName`
-            // field (populated by mapAccountBasePayloadToAccountBase from the backend
-            // payload) — no client-side label map required.
-            return transaction.transaction.paymentType;
-        }
-        case 'category': {
-            // Get from transactionLocalData (preferred) or from transaction lines
-            const localDataForCategory = transaction.transactionLocalData?.transactionReviewLocalData;
-            if (localDataForCategory) {
-                // Get category from first line item or most common
-                const firstLineItem = Object.values(localDataForCategory.lineItemById)[0];
-                if (firstLineItem?.account?.accountId) {
-                    return firstLineItem.account.accountId;
-                }
-                if (firstLineItem?.account?.qboId) {
-                    return firstLineItem.account.qboId;
-                }
-                if (firstLineItem?.account?.accountName) {
-                    return firstLineItem.account.accountName;
-                }
-            }
-            // Fallback to transaction lines
-            const firstLineForCategory = transaction.transaction.lines?.[0];
-            if (firstLineForCategory?.type ===
-                'transaction_with_account_and_class_line' ||
-                firstLineForCategory?.type ===
-                    'transaction_with_product_or_service_line' ||
-                firstLineForCategory?.type === 'journal_entry_transaction_line') {
-                const account = firstLineForCategory.account;
-                return account?.accountId ?? account?.qboId ?? account?.accountName;
-            }
-            return undefined;
-        }
-        case 'class': {
-            // Similar to category but for class
-            const localDataForClass = transaction.transactionLocalData?.transactionReviewLocalData;
-            if (localDataForClass) {
-                const firstLineItemForClass = Object.values(localDataForClass.lineItemById)[0];
-                if (firstLineItemForClass?.class?.classId) {
-                    return firstLineItemForClass.class.classId;
-                }
-                if (firstLineItemForClass?.class?.qboId) {
-                    return firstLineItemForClass.class.qboId;
-                }
-                if (firstLineItemForClass?.class?.className) {
-                    return firstLineItemForClass.class.className;
-                }
-            }
-            const firstLineForClass = transaction.transaction.lines?.[0];
-            if (firstLineForClass?.type === 'transaction_with_account_and_class_line' ||
-                firstLineForClass?.type ===
-                    'transaction_with_product_or_service_line' ||
-                firstLineForClass?.type === 'journal_entry_transaction_line') {
-                const classData = firstLineForClass.class;
-                return classData?.classId ?? classData?.qboId ?? classData?.className;
-            }
-            return undefined;
-        }
-        default:
-            return undefined;
-    }
-};
 const getCategoryValueForPaymentHistory = (key, repayment) => {
     switch (key) {
         case 'repaymentDate':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zeniai/client-epic-state",
-  "version": "5.0.55-betaAR4",
+  "version": "5.0.55-betaAR6",
   "description": "Shared module between Web & Mobile containing required abstractions for state management, async network communication. ",
   "main": "lib/index.js",
   "module": "lib/esm/index.js",