@zeniai/client-epic-state 5.0.85-betaAR2 → 5.0.85-betaAR3

package/lib/esm/view/expenseAutomationView/transactionFilterHelpers.js

@@ -28,28 +28,57 @@ export const TRANSACTION_FILTER_CATEGORIES = [
     { value: 'class', type: 'dropdown' },
     { value: 'amount', type: 'numberRange' },
 ];
+/**
+ * Per-line amounts for a transaction, preserving the canonical source
+ * precedence:
+ *
+ *   1. `transactionLocalData.transactionReviewLocalData.lineItemById` —
+ *      the locally-edited line items the user sees in the grid. Reflects
+ *      unsaved edits so the filter matches what the user actually has on
+ *      screen, not the pre-edit server state.
+ *   2. `transaction.transaction.lines` — persisted lines from the
+ *      transaction payload.
+ *   3. `[transaction.amount.amount]` — single-element fallback for
+ *      transactions that don't have a `lines` array at all (treat the
+ *      transaction-level amount as a one-line transaction).
+ *
+ * Returned as an array so the amount filter in `transactionMatchesCategory`
+ * can OR-combine per-line `matchAmount` results: a transaction is included
+ * if ANY of its lines satisfies the operator, and the full row (with all
+ * lines, matching or not) renders downstream. Before the per-line change
+ * this helper's predecessor in `getCategoryValueForTransaction` summed
+ * these values into a single aggregate and compared the sum.
+ */
+const getLineAmountsForTransaction = (transaction) => {
+    const localData = transaction.transactionLocalData?.transactionReviewLocalData;
+    if (localData?.lineItemById != null) {
+        const lineItems = Object.values(localData.lineItemById);
+        if (lineItems.length > 0) {
+            return lineItems.map((lineItem) => lineItem.amount?.amount ?? 0);
+        }
+    }
+    if (transaction.transaction.lines != null &&
+        transaction.transaction.lines.length > 0) {
+        return transaction.transaction.lines.map((line) => line.amount?.amount ?? 0);
+    }
+    return [transaction.amount.amount];
+};
 /**
  * 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).
+ *
+ * NOTE: the `'amount'` field is NOT handled here. Amount matching is
+ * per-line (see `getLineAmountsForTransaction` + the early-return in
+ * `transactionMatchesCategory`) and would otherwise need to return a
+ * non-scalar value that doesn't fit this helper's contract.
  */
 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;
+            // Handled per-line in `transactionMatchesCategory` — see the note on
+            // this function's JSDoc and `getLineAmountsForTransaction` above.
+            return undefined;
         }
         case 'payee': {
             if (isNonEmptyString(transaction.vendorName)) {
@@ -187,6 +216,27 @@ const matchAmount = (amount, category) => {
     return op === 'not_equal' ? !matched : matched;
 };
 const transactionMatchesCategory = (transaction, category) => {
+    if (category.field === 'amount') {
+        // Per-line matching: the transaction is included if ANY of its lines
+        // satisfies the operator. This is what the user expects when a
+        // multi-line transaction contains lines at different amounts — they
+        // want the row to surface if even one line falls in the filter's
+        // range. The full row (with non-matching lines too) renders
+        // downstream; this matcher only decides row inclusion. Same
+        // operator + sign semantics as the aggregate version, just applied
+        // per line.
+        //
+        // `not_equal` deserves a sanity-check: `matchAmount` already inverts
+        // internally for that operator, so for a line whose amount is NOT
+        // in the filter's `values`, matchAmount returns true; for a line
+        // whose amount IS in the values, it returns false. `.some()` over
+        // lines therefore means "the transaction has at least one line that
+        // is not equal to any of the filter values" — which is the right
+        // match-any-line interpretation of `not_equal` (a transaction
+        // matches if it has a line that satisfies the negation).
+        const lineAmounts = getLineAmountsForTransaction(transaction);
+        return lineAmounts.some((lineAmount) => matchAmount(lineAmount, category));
+    }
     const value = getCategoryValueForTransaction(category.field, transaction);
     if (value == null) {
         // Absent-value semantics — pinning these down explicitly so the
@@ -206,12 +256,10 @@ const transactionMatchesCategory = (transaction, category) => {
         //              are filtered out.
         //
         // Only the `not_equal` branch returns `true` here; everything else
-        // falls through to the `false` below.
+        // falls through to the `false` below. Note: 'amount' never lands here
+        // because it short-circuits to the per-line path above.
         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;

package/lib/view/expenseAutomationView/transactionFilterHelpers.js

@@ -31,28 +31,57 @@ exports.TRANSACTION_FILTER_CATEGORIES = [
     { value: 'class', type: 'dropdown' },
     { value: 'amount', type: 'numberRange' },
 ];
+/**
+ * Per-line amounts for a transaction, preserving the canonical source
+ * precedence:
+ *
+ *   1. `transactionLocalData.transactionReviewLocalData.lineItemById` —
+ *      the locally-edited line items the user sees in the grid. Reflects
+ *      unsaved edits so the filter matches what the user actually has on
+ *      screen, not the pre-edit server state.
+ *   2. `transaction.transaction.lines` — persisted lines from the
+ *      transaction payload.
+ *   3. `[transaction.amount.amount]` — single-element fallback for
+ *      transactions that don't have a `lines` array at all (treat the
+ *      transaction-level amount as a one-line transaction).
+ *
+ * Returned as an array so the amount filter in `transactionMatchesCategory`
+ * can OR-combine per-line `matchAmount` results: a transaction is included
+ * if ANY of its lines satisfies the operator, and the full row (with all
+ * lines, matching or not) renders downstream. Before the per-line change
+ * this helper's predecessor in `getCategoryValueForTransaction` summed
+ * these values into a single aggregate and compared the sum.
+ */
+const getLineAmountsForTransaction = (transaction) => {
+    const localData = transaction.transactionLocalData?.transactionReviewLocalData;
+    if (localData?.lineItemById != null) {
+        const lineItems = Object.values(localData.lineItemById);
+        if (lineItems.length > 0) {
+            return lineItems.map((lineItem) => lineItem.amount?.amount ?? 0);
+        }
+    }
+    if (transaction.transaction.lines != null &&
+        transaction.transaction.lines.length > 0) {
+        return transaction.transaction.lines.map((line) => line.amount?.amount ?? 0);
+    }
+    return [transaction.amount.amount];
+};
 /**
  * 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).
+ *
+ * NOTE: the `'amount'` field is NOT handled here. Amount matching is
+ * per-line (see `getLineAmountsForTransaction` + the early-return in
+ * `transactionMatchesCategory`) and would otherwise need to return a
+ * non-scalar value that doesn't fit this helper's contract.
  */
 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;
+            // Handled per-line in `transactionMatchesCategory` — see the note on
+            // this function's JSDoc and `getLineAmountsForTransaction` above.
+            return undefined;
         }
         case 'payee': {
             if (isNonEmptyString(transaction.vendorName)) {
@@ -190,6 +219,27 @@ const matchAmount = (amount, category) => {
     return op === 'not_equal' ? !matched : matched;
 };
 const transactionMatchesCategory = (transaction, category) => {
+    if (category.field === 'amount') {
+        // Per-line matching: the transaction is included if ANY of its lines
+        // satisfies the operator. This is what the user expects when a
+        // multi-line transaction contains lines at different amounts — they
+        // want the row to surface if even one line falls in the filter's
+        // range. The full row (with non-matching lines too) renders
+        // downstream; this matcher only decides row inclusion. Same
+        // operator + sign semantics as the aggregate version, just applied
+        // per line.
+        //
+        // `not_equal` deserves a sanity-check: `matchAmount` already inverts
+        // internally for that operator, so for a line whose amount is NOT
+        // in the filter's `values`, matchAmount returns true; for a line
+        // whose amount IS in the values, it returns false. `.some()` over
+        // lines therefore means "the transaction has at least one line that
+        // is not equal to any of the filter values" — which is the right
+        // match-any-line interpretation of `not_equal` (a transaction
+        // matches if it has a line that satisfies the negation).
+        const lineAmounts = getLineAmountsForTransaction(transaction);
+        return lineAmounts.some((lineAmount) => matchAmount(lineAmount, category));
+    }
     const value = getCategoryValueForTransaction(category.field, transaction);
     if (value == null) {
         // Absent-value semantics — pinning these down explicitly so the
@@ -209,12 +259,10 @@ const transactionMatchesCategory = (transaction, category) => {
         //              are filtered out.
         //
         // Only the `not_equal` branch returns `true` here; everything else
-        // falls through to the `false` below.
+        // falls through to the `false` below. Note: 'amount' never lands here
+        // because it short-circuits to the per-line path above.
         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;

package/package.json

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