@zeniai/client-epic-state 5.0.88-betaAR2 → 5.0.88-betaAS2

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

@@ -28,87 +28,28 @@ 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.
- *
- * **Missing amounts.** Lines (or transactions) whose amount field is
- * `null` / `undefined` / `NaN` are *dropped* from the returned array
- * rather than coerced to `0`. Coercing to `0` would silently make a
- * row with no amount data match operators like `less_than 100`, even
- * though we genuinely don't know what the amount is — a semantic
- * regression flagged in PR review. By filtering instead, the empty-array
- * case bubbles up to `transactionMatchesCategory`, which falls back to
- * the same "absent value: only `not_equal` matches" contract used by
- * non-amount fields.
- *
- * The defensive `?.` chains stay in place so a partial payload (state
- * init, Pusher mid-sync, partially-resolved server response) doesn't
- * throw; the difference is `?? 0` → filter-out.
- */
-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)
-                .filter(isFiniteNumber);
-        }
-    }
-    if (transaction?.transaction?.lines != null &&
-        transaction.transaction.lines.length > 0) {
-        return transaction.transaction.lines
-            .map((line) => line?.amount?.amount)
-            .filter(isFiniteNumber);
-    }
-    const txAmount = transaction?.amount?.amount;
-    return isFiniteNumber(txAmount) ? [txAmount] : [];
-};
-/**
- * Type guard that survives an `Array<number | undefined>.filter(...)` and
- * narrows the result to `number[]`. Also rejects `NaN` so downstream
- * `matchAmount` never sees a value that fails every operator silently
- * (because every comparison with `NaN` is false, `NaN < 100`, `NaN > 100`,
- * `NaN === N` all yield `false` — the row would silently slip through
- * `not_equal` but fail every other operator, which is exactly the
- * absent-value contract we want to apply explicitly via an empty array
- * instead).
- */
-const isFiniteNumber = (value) => typeof value === 'number' && Number.isFinite(value);
 /**
  * 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': {
-            // Handled per-line in `transactionMatchesCategory` — see the note on
-            // this function's JSDoc and `getLineAmountsForTransaction` above.
-            return undefined;
+            // 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)) {
@@ -246,37 +187,6 @@ 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);
-        if (lineAmounts.length === 0) {
-            // No valid (finite) amount data on the transaction or its lines —
-            // apply the same absent-value contract the generic branch below
-            // uses for non-amount fields: only `not_equal` matches a missing
-            // value, every other operator excludes it. Coercing missing
-            // amounts to `0` upstream (the previous behavior) would have made
-            // such rows silently match `less_than 100`, `in_between [0, 50]`,
-            // etc., which the PR review correctly flagged as a regression.
-            return category.matchingOperator === 'not_equal';
-        }
-        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
@@ -296,10 +206,12 @@ const transactionMatchesCategory = (transaction, category) => {
         //              are filtered out.
         //
         // Only the `not_equal` branch returns `true` here; everything else
-        // falls through to the `false` below. Note: 'amount' never lands here
-        // because it short-circuits to the per-line path above.
+        // 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;

package/lib/view/expenseAutomationView/transactionFilterHelpers.js

@@ -31,87 +31,28 @@ 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.
- *
- * **Missing amounts.** Lines (or transactions) whose amount field is
- * `null` / `undefined` / `NaN` are *dropped* from the returned array
- * rather than coerced to `0`. Coercing to `0` would silently make a
- * row with no amount data match operators like `less_than 100`, even
- * though we genuinely don't know what the amount is — a semantic
- * regression flagged in PR review. By filtering instead, the empty-array
- * case bubbles up to `transactionMatchesCategory`, which falls back to
- * the same "absent value: only `not_equal` matches" contract used by
- * non-amount fields.
- *
- * The defensive `?.` chains stay in place so a partial payload (state
- * init, Pusher mid-sync, partially-resolved server response) doesn't
- * throw; the difference is `?? 0` → filter-out.
- */
-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)
-                .filter(isFiniteNumber);
-        }
-    }
-    if (transaction?.transaction?.lines != null &&
-        transaction.transaction.lines.length > 0) {
-        return transaction.transaction.lines
-            .map((line) => line?.amount?.amount)
-            .filter(isFiniteNumber);
-    }
-    const txAmount = transaction?.amount?.amount;
-    return isFiniteNumber(txAmount) ? [txAmount] : [];
-};
-/**
- * Type guard that survives an `Array<number | undefined>.filter(...)` and
- * narrows the result to `number[]`. Also rejects `NaN` so downstream
- * `matchAmount` never sees a value that fails every operator silently
- * (because every comparison with `NaN` is false, `NaN < 100`, `NaN > 100`,
- * `NaN === N` all yield `false` — the row would silently slip through
- * `not_equal` but fail every other operator, which is exactly the
- * absent-value contract we want to apply explicitly via an empty array
- * instead).
- */
-const isFiniteNumber = (value) => typeof value === 'number' && Number.isFinite(value);
 /**
  * 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': {
-            // Handled per-line in `transactionMatchesCategory` — see the note on
-            // this function's JSDoc and `getLineAmountsForTransaction` above.
-            return undefined;
+            // 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)) {
@@ -249,37 +190,6 @@ 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);
-        if (lineAmounts.length === 0) {
-            // No valid (finite) amount data on the transaction or its lines —
-            // apply the same absent-value contract the generic branch below
-            // uses for non-amount fields: only `not_equal` matches a missing
-            // value, every other operator excludes it. Coercing missing
-            // amounts to `0` upstream (the previous behavior) would have made
-            // such rows silently match `less_than 100`, `in_between [0, 50]`,
-            // etc., which the PR review correctly flagged as a regression.
-            return category.matchingOperator === 'not_equal';
-        }
-        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
@@ -299,10 +209,12 @@ const transactionMatchesCategory = (transaction, category) => {
         //              are filtered out.
         //
         // Only the `not_equal` branch returns `true` here; everything else
-        // falls through to the `false` below. Note: 'amount' never lands here
-        // because it short-circuits to the per-line path above.
+        // 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;

package/package.json

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