@zeniai/client-epic-state 5.0.69-betaAR5 → 5.0.69-betaAS1

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

@@ -1,66 +0,0 @@
-/**
- * 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

@@ -1,249 +0,0 @@
-"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 !== '';
-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 = Object.values(localDataForCategory.lineItemById)[0];
-                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 = Object.values(localDataForClass.lineItemById)[0];
-                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;