@zeniai/client-epic-state 5.0.73 → 5.0.74

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

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.toTransactionView = void 0;
 exports.getExpenseAutomationTransactionView = getExpenseAutomationTransactionView;
 const omit_1 = __importDefault(require("lodash/omit"));
 const reduceFetchState_1 = require("../../../commonStateTypes/reduceFetchState");
@@ -10,14 +11,34 @@ 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 transactionFilterHelpers_1 = require("../transactionFilterHelpers");
 const accountListSelector_1 = require("../../accountList/accountListSelector");
 const classListSelector_1 = require("../../classList/classListSelector");
 const projectListSelector_1 = require("../../projectList/projectListSelector");
 const expenseAutomationViewSelectorTypes_1 = require("../selectorTypes/expenseAutomationViewSelectorTypes");
+const toTransactionView = (transaction, transactionLocalData) => {
+    return {
+        id: transaction.id,
+        date: transaction.date,
+        amount: transaction.amount,
+        vendorName: transaction.vendorName,
+        customerName: transaction.customerName,
+        vendorId: transaction.vendorId,
+        customerId: transaction.customerId,
+        description: transaction.description,
+        memo: transaction.memo,
+        type: transaction.type,
+        typeName: transaction.typeName,
+        createTime: transaction.createTime,
+        transaction: transaction,
+        transactionLocalData,
+    };
+};
+exports.toTransactionView = toTransactionView;
 function getExpenseAutomationTransactionView(state) {
     const { accountState, classState, classListState, accountListState, expenseAutomationTransactionsViewState, expenseAutomationViewState, projectState, projectListState, transactionState, monthEndCloseChecksState, monthEndCloseChecksViewState, } = state;
     const { selectedTransactionCategorizationCompletedSubTab, selectedTransactionCategorizationTab, } = expenseAutomationTransactionsViewState;
-    const { uiState, refreshStatus, saveStatus, markAsNotMiscategorizedStatus, transactionIdsBySelectedPeriod, transactionReviewLocalDataById, selectedCheckBoxTransactionIds, transactionIdsWithUnsavedData, uploadReceiptStatusById, selectedTransactionId, selectedTransactionLineId, } = expenseAutomationTransactionsViewState.transactionCategorizationView[selectedTransactionCategorizationTab];
+    const { uiState, refreshStatus, saveStatus, markAsNotMiscategorizedStatus, transactionIdsBySelectedPeriod, transactionReviewLocalDataById, selectedCheckBoxTransactionIds, transactionIdsWithUnsavedData, uploadReceiptStatusById, selectedTransactionId, selectedTransactionLineId, filters, } = expenseAutomationTransactionsViewState.transactionCategorizationView[selectedTransactionCategorizationTab];
     const uncategorizedIncomeExpense = (0, accountListSelector_1.getUncategorizedAccounts)(accountState, accountListState, 'accountList');
     const accountList = (0, accountListSelector_1.getAccountList)(accountState, accountListState, 'accountList');
     const classList = (0, classListSelector_1.getClassList)(classState, classListState);
@@ -36,20 +57,58 @@ function getExpenseAutomationTransactionView(state) {
         ? transactionIdsBySelectedPeriod[monthYearPeriodId]
         : null;
     const transactionIds = transactionIdsForSelectedPeriod ?? [];
-    const transactionLocalData = transactionIds
-        .map((transactionId) => {
+    const transactions = (0, transactionSelector_1.getSupportedTransactionsByIds)(transactionState, transactionIds);
+    const transactionsWithCOT = transactions.map((transaction) => (0, transactionHelper_1.getTransactionWithCOT)(transaction));
+    const transactionLocalDataMap = new Map();
+    transactionIds.forEach((transactionId) => {
         const transactionData = transactionReviewLocalDataById[transactionId];
         if (transactionData != null) {
-            return {
+            transactionLocalDataMap.set(transactionId, {
                 transactionId,
                 transactionReviewLocalData: transactionData.transactionReviewLocalData,
-            };
+            });
         }
-        return null;
-    })
-        .filter((transaction) => transaction != null);
-    const transactions = (0, transactionSelector_1.getSupportedTransactionsByIds)(transactionState, transactionIds);
-    const transactionsWithCOT = transactions.map((transaction) => (0, transactionHelper_1.getTransactionWithCOT)(transaction));
+    });
+    // Step 2: Convert to TransactionView and apply advanced filters
+    const transactionViews = transactionsWithCOT.map((transaction) => {
+        const localData = transactionLocalDataMap.get(transaction.id);
+        return (0, exports.toTransactionView)(transaction, localData);
+    });
+    // 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
+    // Also include transactionLocalData for transactions that don't exist in transactionState
+    // but have local data (to match original behavior)
+    const filteredTransactionIds = new Set(filteredTransactionViews.map((view) => view.id));
+    // Pre-compute the membership set once. The previous implementation called
+    // `transactions.some(t => t.id === transactionId)` inside the per-id loop,
+    // turning the pipeline into O(n × m) — measurable on tenants with large
+    // transaction lists since this selector runs on every Redux dispatch.
+    const transactionExistsById = new Set(transactions.map((t) => t.id));
+    // `.flatMap` returns `X[]` directly when the callback returns `[]` for the
+    // skip case, so we don't need the trailing `.filter((d): d is X => …)` type
+    // predicate that the previous `map → filter` pipeline required.
+    const filteredTransactionLocalData = transactionIds.flatMap((transactionId) => {
+        const transactionData = transactionReviewLocalDataById[transactionId];
+        if (transactionData == null) {
+            return [];
+        }
+        // Include if transaction is in filtered results, or if transaction doesn't exist in state
+        // (to maintain backward compatibility with tests)
+        const transactionExists = transactionExistsById.has(transactionId);
+        if (filteredTransactionIds.has(transactionId) || !transactionExists) {
+            return [
+                {
+                    transactionId,
+                    transactionReviewLocalData: transactionData.transactionReviewLocalData,
+                },
+            ];
+        }
+        return [];
+    });
     const monthEndFetchState = monthYearPeriodId != null
         ? (monthEndCloseChecksViewState.monthEndCloseChecksViewByTenantId[currentTenant.tenantId]?.[monthYearPeriodId] ?? { fetchState: 'Not-Started', error: undefined })
         : { fetchState: 'Not-Started', error: undefined };
@@ -113,7 +172,7 @@ function getExpenseAutomationTransactionView(state) {
         version: 0,
         fetchState: fetchStatus.fetchState,
         error: fetchStatus.error,
-        transactions: transactionsWithCOT,
+        transactions: filteredTransactionsWithCOT,
         selectedCheckBoxTransactionIds,
         transactionIdsWithUnsavedData,
         uncategorizedAccounts: uncategorizedIncomeExpense,
@@ -124,7 +183,7 @@ function getExpenseAutomationTransactionView(state) {
         classHierarchyList,
         isAccountingProjectsEnabled,
         projectList,
-        transactionLocalData,
+        transactionLocalData: filteredTransactionLocalData,
         uiState,
         refreshStatus,
         saveStatus,

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

@@ -0,0 +1,66 @@
+/**
+ * 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. Shared primitives
+ * (`CategoryCombinationOperator`, `FilterCategoryType`) come from
+ * `commonStateTypes/filterPrimitives`, which both feature groups consume.
+ */
+import { Amount } from '../../commonStateTypes/amount';
+import { ID } from '../../commonStateTypes/common';
+import { CategoryCombinationOperator, FilterCategoryType } from '../../commonStateTypes/filterPrimitives';
+import { TransactionType } from '../../entity/transaction/stateTypes/transactionType';
+import { SupportedTransactionWithCOT } from '../../entity/transaction/transactionState';
+import { ZeniDate } from '../../zeniDayJS';
+import { TransactionReviewLocalDataSelectorView } from './selectorTypes/transactionsViewSelectorTypes';
+/**
+ * Re-exported here so the CES barrel can pull TC's primitives from the
+ * Expense Automation surface without reaching into `commonStateTypes`
+ * directly — keeps the barrel's existing import topology stable.
+ */
+export type { CategoryCombinationOperator, FilterCategoryType };
+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' | 'less_than' | 'greater_than' | 'in_between';
+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: 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;
+}
+/**
+ * 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,262 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyTransactionFilters = exports.TRANSACTION_FILTER_CATEGORIES = void 0;
+/**
+ * Narrowing type-guard for "has a non-empty string here". Used in place of
+ * raw `if (foo)` truthiness checks on `string | null | undefined` values so
+ * the `@typescript-eslint/strict-boolean-expressions` lint stays clean —
+ * empty strings should explicitly fall through to the next candidate
+ * (vendorName → customerName → localData.vendor.name → ...) rather than
+ * being implicitly coerced to falsy.
+ */
+const isNonEmptyString = (s) => s != null && s !== '';
+/**
+ * First line item in UI order. `lineItemById` is a Record whose iteration
+ * order is not guaranteed to match what the user sees; `sortedLineItems`
+ * is the canonical ordering used by the categorization list/detail views.
+ */
+const getFirstLineItemFromReviewLocalData = (localData) => {
+    const { sortedLineItems, lineItemById } = localData;
+    if (sortedLineItems.length > 0) {
+        return lineItemById[sortedLineItems[0]];
+    }
+    const lineItems = Object.values(lineItemById);
+    return lineItems.length > 0 ? lineItems[0] : undefined;
+};
+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 (isNonEmptyString(transaction.vendorName)) {
+                return transaction.vendorName;
+            }
+            if (isNonEmptyString(transaction.customerName)) {
+                return transaction.customerName;
+            }
+            const localData = transaction.transactionLocalData?.transactionReviewLocalData;
+            const vendorName = localData?.vendor?.name;
+            if (isNonEmptyString(vendorName)) {
+                return vendorName;
+            }
+            const customerName = localData?.customer?.name;
+            if (isNonEmptyString(customerName)) {
+                return customerName;
+            }
+            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 != null) {
+                const firstLineItem = getFirstLineItemFromReviewLocalData(localDataForCategory);
+                const accountId = firstLineItem?.account?.accountId;
+                if (isNonEmptyString(accountId)) {
+                    return accountId;
+                }
+                const qboId = firstLineItem?.account?.qboId;
+                if (isNonEmptyString(qboId)) {
+                    return qboId;
+                }
+                const accountName = firstLineItem?.account?.accountName;
+                if (isNonEmptyString(accountName)) {
+                    return 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 != null) {
+                const firstLineItemForClass = getFirstLineItemFromReviewLocalData(localDataForClass);
+                const classId = firstLineItemForClass?.class?.classId;
+                if (isNonEmptyString(classId)) {
+                    return classId;
+                }
+                const qboId = firstLineItemForClass?.class?.qboId;
+                if (isNonEmptyString(qboId)) {
+                    return qboId;
+                }
+                const className = firstLineItemForClass?.class?.className;
+                if (isNonEmptyString(className)) {
+                    return 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).
+ *
+ * The `'equal' | 'not_equal'` branch matches if `amount` equals ANY of the
+ * configured values (consistent with how non-amount filters interpret a
+ * multi-value `values` array). `.some()` over the values array also makes
+ * the empty-values case behave correctly — empty array → `matched = false`
+ * — though in practice `applyTransactionFilters` strips empty-values
+ * categories before they reach this matcher. The trailing
+ * `op === 'not_equal' ? !matched : matched` line inverts for `not_equal`.
+ */
+const matchAmount = (amount, category) => {
+    const op = category.matchingOperator;
+    const values = category.values;
+    let matched = false;
+    if (op === 'in_between') {
+        if (values.length >= 2) {
+            const min = Number(values[0]);
+            const max = Number(values[1]);
+            matched = amount >= min && amount <= max;
+        }
+    }
+    else if (op === 'less_than') {
+        if (values.length >= 1) {
+            matched = amount < Number(values[0]);
+        }
+    }
+    else if (op === 'greater_than') {
+        if (values.length >= 1) {
+            matched = amount > Number(values[0]);
+        }
+    }
+    else if (op === 'equal' || op === 'not_equal') {
+        matched = values.some((v) => {
+            const s = String(v);
+            // Backward compatibility: legacy "low<->high" range-string form
+            // persisted under `matchingOperator: 'equal'`.
+            if (s.includes('<->')) {
+                const parts = s.split('<->');
+                return (amount >= Number(parts[0] ?? '') && amount <= Number(parts[1] ?? ''));
+            }
+            return amount === Number(v);
+        });
+    }
+    return op === 'not_equal' ? !matched : matched;
+};
+const transactionMatchesCategory = (transaction, category) => {
+    const value = getCategoryValueForTransaction(category.field, transaction);
+    if (value == null) {
+        // Absent-value semantics — pinning these down explicitly so the
+        // asymmetry isn't surprising:
+        //
+        //   not_equal: a missing value IS NOT EQUAL to any candidate, so the
+        //              transaction matches the filter (passes through).
+        //   equal:     a missing value is not equal to any candidate, so the
+        //              transaction does NOT match (filtered out).
+        //   less_than / greater_than: SQL-style three-valued logic — comparing
+        //              against a missing value is "unknown", which we treat as
+        //              "does not match" (filtered out). A user setting
+        //              "amount < $1000" probably wants transactions with a
+        //              concrete amount that satisfies the bound, not rows
+        //              where the amount can't be determined.
+        //   in_between: same as the single-sided comparators — missing values
+        //              are filtered out.
+        //
+        // Only the `not_equal` branch returns `true` here; everything else
+        // falls through to the `false` below.
+        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;
+    }
+    // Mirrors the predicate used by `getTransactionAppliedFiltersCount` on the
+    // webc side. A half-filled category — e.g. `in_between` with only the
+    // `min` typed — would otherwise survive the filter pass and produce zero
+    // matches because `Number("")` collapses to `0`, artificially emptying
+    // the list while editing. Skipping such categories keeps the filtered
+    // view stable while the user finishes typing.
+    const activeCategories = filters.categories.filter((c) => {
+        if (c.field == null || c.values.length === 0) {
+            return false;
+        }
+        if (c.field === 'amount' && c.matchingOperator === 'in_between') {
+            return (c.values.length >= 2 &&
+                String(c.values[0] ?? '').trim() !== '' &&
+                String(c.values[1] ?? '').trim() !== '');
+        }
+        return String(c.values[0] ?? '').trim() !== '';
+    });
+    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

@@ -16,6 +16,7 @@ import { VendorBase } from '../../../entity/vendor/vendorState';
 import { ZeniAPIStatus } from '../../../responsePayload';
 import { ZeniDate } from '../../../zeniDayJS';
 import { EntityRecommendationKey } from '../../recommendation/recommendationState';
+import { TransactionFilters } from '../transactionFilterHelpers';
 import { TransactionDetailKey } from '../../transactionDetail/transactionDetailState';
 import { CompletedSubTab } from './completedSubTab';
 export declare const toTransactionsSortKey: (v: string) => "date" | "amount" | "vendor" | "project" | "category" | "class" | "payment_account" | "transaction_type" | "memo_and_receipt";
@@ -93,6 +94,7 @@ export interface SupportedTransactionCategorization {
 }
 export declare const initialSupportedTransactionCategorization: SupportedTransactionCategorization;
 export interface TransactionsTabViewState extends FetchedState {
+    filters: TransactionFilters;
     markAsNotMiscategorizedStatus: FetchStateAndError;
     refreshStatus: FetchStateAndError;
     saveStatus: FetchStateAndError;

package/lib/view/spendManagement/billPay/billList/billListState.d.ts

@@ -45,7 +45,7 @@ export interface BillPayFilters {
 }
 export interface BillPayFilterCategory {
     field: BillListViewFilterCategoryField;
-    matchingOperator: 'equal' | 'not-equal';
+    matchingOperator: 'equal' | 'not_equal';
     values: (string | ZeniDate)[];
     valuesCombinationOperator: 'ANY';
 }

package/lib/view/spendManagement/chargeCards/chargeCardPaymentHistory/chargeCardPaymentHistory.d.ts

@@ -36,7 +36,7 @@ export interface PaymentHistoryFilters {
 }
 export interface PaymentHistoryFilterCategory {
     field: PaymentHistoryFilterCategoryField;
-    matchingOperator: 'equal' | 'not-equal';
+    matchingOperator: 'equal' | 'not_equal';
     values: (string | ZeniDate)[];
     valuesCombinationOperator: 'ANY';
 }

package/lib/view/spendManagement/reimbursement/remiListView/remiListState.d.ts

@@ -46,7 +46,7 @@ export interface ReimbursementFilters {
 }
 export interface ReimbursementFilterCategory {
     field: RemiListViewFilterCategoryField;
-    matchingOperator: 'equal' | 'not-equal';
+    matchingOperator: 'equal' | 'not_equal';
     values: (string | ZeniDate)[];
     valuesCombinationOperator: 'ANY';
 }

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

@@ -1,3 +1,4 @@
+import { CategoryCombinationOperator, FilterCategoryType } from '../../commonStateTypes/filterPrimitives';
 import { TimePeriod } from '../../commonStateTypes/timePeriod';
 import { UserRoleType } from '../../entity/userRole/userRoleType';
 import { RootState } from '../../reducer';
@@ -12,12 +13,20 @@ import { ReimbursementView } from './reimbursement/remiListView/remiListSelector
 import { ReimbursementFilters, RemiListViewFilterCategoryField } from './reimbursement/remiListView/remiListState';
 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';
+/**
+ * Re-exported here so consumers of `spendManagementFilterHelpers` keep
+ * their existing import path stable after the primitives moved to
+ * `commonStateTypes/filterPrimitives`. Downstream files (`taskList`,
+ * `remiListState`, `chargeCardPaymentHistory`, `billListState`) and the
+ * CES barrel still pull `CategoryCombinationOperator` / `FilterCategoryType`
+ * from this module — the source of truth is upstream but the surface is
+ * unchanged.
+ */
+export type { CategoryCombinationOperator, FilterCategoryType };
 export interface MatchingOperatorDropdownOption {
     label: 'is' | 'is not';
-    value: 'equal' | 'not-equal';
+    value: 'equal' | 'not_equal';
 }
-export type CategoryCombinationOperator = 'AND' | 'OR';
 export interface BillPayFilterCategoryDropdownOption {
     value: BillListViewFilterCategoryField;
     multiple?: boolean;

package/lib/view/spendManagement/spendManagementFilterHelpers.js

@@ -14,6 +14,8 @@ const helpers_1 = require("./helpers");
 const remiListSelector_1 = require("./reimbursement/remiListView/remiListSelector");
 const remiListState_1 = require("./reimbursement/remiListView/remiListState");
 //filters items against filter values representing a range. ex: date (from-to), amount(1k<-->5k)
+// 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;
@@ -47,7 +49,7 @@ const filterItemOnCategoriesWithSingleValue = (categoryValue, currentFilter, ran
         return filterItemOnRangeCategoryType(categoryValue, currentFilter);
     }
     // if filter category is not rangeType
-    if (currentFilter.matchingOperator === 'not-equal') {
+    if (currentFilter.matchingOperator === 'not_equal') {
         return currentFilter.values.indexOf(categoryValue.toString()) === -1;
     }
     return currentFilter.values.indexOf(categoryValue.toString()) > -1;
@@ -121,7 +123,7 @@ const applyAdvancedFiltersOnList = (entity, allItems, filters, filteredItems = [
                     ? getCategoryValueForTaskList(key, item)
                     : getCategoryValueForPaymentHistory(key, item);
         if (categoryValue == null) {
-            if (currentFilter.matchingOperator === 'not-equal') {
+            if (currentFilter.matchingOperator === 'not_equal') {
                 return true;
             }
             return false;

package/lib/view/subscriptionView/subscriptionViewSelector.js

@@ -217,7 +217,7 @@ const applyAdvancedFiltersOnCompaniesList = (allCompanies, filters, filteredComp
         const key = currentFilter.field;
         const categoryValue = getCategoryValueForCompany(key, company);
         if (categoryValue == null) {
-            if (currentFilter.matchingOperator === 'not-equal') {
+            if (currentFilter.matchingOperator === 'not_equal') {
                 return true;
             }
             return false;

package/lib/view/taskManager/taskListView/taskList.d.ts

@@ -44,7 +44,7 @@ export interface TaskListFilters {
 }
 export interface TaskFilterCategory {
     field: TaskListFilterCategoryField;
-    matchingOperator: 'equal' | 'not-equal';
+    matchingOperator: 'equal' | 'not_equal';
     values: (string | ZeniDate)[];
     valuesCombinationOperator: 'ANY';
 }

package/lib/view/taskManager/taskListView/taskListReducer.js

@@ -70,7 +70,7 @@ exports.initialState = {
         categories: [
             {
                 field: 'status',
-                matchingOperator: 'not-equal',
+                matchingOperator: 'not_equal',
                 values: ['resolved'],
                 valuesCombinationOperator: 'ANY',
             },

package/package.json

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