washday-sdk 1.6.70 → 1.6.72

package/dist/utils/orders/calculateOrderTotal.js

@@ -1,7 +1,7 @@
 import { DiscountCodeTypes } from "../../enum";
 import { calculateTotalTaxesIncluded } from "./calculateTotalTaxesIncluded";
 import { calculateTotalTaxesOverPrice } from "./calculateTotalTaxesOverPrice";
-import { getCreditApplied, getProductLineTotals, getShippingCost } from "./helpers";
+import { applyDiscountToProducts, getCreditApplied, getProductLineTotals, getShippingCost, } from "./helpers";
 const getNormalizedId = (value) => {
     if (value === null || value === undefined) {
         return "";
@@ -41,38 +41,80 @@ export const calculateOrderTotal = (order, selectedCustomer, storeSettings, hasS
     var _a, _b, _c;
     try {
         const appliedOrderDiscounts = {};
+        // For NUMBER coupons (fixed-amount) we must bake `discountAmount` per
+        // line so the tax calculators can reduce the taxable base BEFORE
+        // computing tax. `applyDiscountToProducts` handles both per-unit
+        // (`applyOnceOnOrder=false`) and proportional allocation
+        // (`applyOnceOnOrder=true`). For other coupon types, the tax calc derives
+        // the discount via `discPercentageInteger` so we can skip the pre-pass.
+        let processedOrder = order;
+        if (discountCodeObj && discountCodeObj.type === DiscountCodeTypes.NUMBER) {
+            const { newOrderProds, buyAndGetProds } = applyDiscountToProducts(discountCodeObj, (_a = order.products) !== null && _a !== void 0 ? _a : [], Boolean(order.express), storeDiscounts, selectedCustomer === null || selectedCustomer === void 0 ? void 0 : selectedCustomer.customer);
+            processedOrder = Object.assign(Object.assign({}, order), { products: newOrderProds, buyAndGetProducts: buyAndGetProds && buyAndGetProds.length > 0
+                    ? buyAndGetProds
+                    : (_b = order.buyAndGetProducts) !== null && _b !== void 0 ? _b : [] });
+        }
         const productTableCalculator = (storeSettings === null || storeSettings === void 0 ? void 0 : storeSettings.taxesType) === 'over_price'
             ? calculateTotalTaxesOverPrice
             : calculateTotalTaxesIncluded;
-        const productTableImports = productTableCalculator(order, selectedCustomer, storeSettings, storeDiscounts, appliedOrderDiscounts, discountCodeObj);
+        const productTableImports = productTableCalculator(processedOrder, selectedCustomer, storeSettings, storeDiscounts, appliedOrderDiscounts, discountCodeObj);
         // === PRODUCT LINE TOTALS ===
-        const { totalQuantity, totalImportWithDiscount, totalImportWithoutDiscount, totalImporTaxes, totalDiscountAmount, totalSubtotalAmount, taxBreakdown } = getProductLineTotals(productTableImports);
-        // === DISCOUNT CODE (monetario tipo NUMBER que se aplica una sola vez) ===
-        let discountCodeAmount = 0;
-        if (discountCodeObj &&
-            discountCodeObj.type === DiscountCodeTypes.NUMBER &&
-            discountCodeObj.applyOnceOnOrder) {
-            const includesProducts = discountCodeObj.applyToAllProducts ||
-                order.products.some((curr) => hasMatchingDiscountTarget(discountCodeObj.products, curr));
-            const minimumOrderSubtotal = Number((_a = discountCodeObj.minimumOrderSubtotal) !== null && _a !== void 0 ? _a : 0);
-            const meetsMinimum = !Number.isFinite(minimumOrderSubtotal) ||
-                minimumOrderSubtotal <= 0 ||
-                Number((_b = totalImportWithoutDiscount !== null && totalImportWithoutDiscount !== void 0 ? totalImportWithoutDiscount : totalSubtotalAmount) !== null && _b !== void 0 ? _b : 0) >= minimumOrderSubtotal;
-            discountCodeAmount = includesProducts && meetsMinimum ? discountCodeObj.value : 0;
-        }
+        const { totalQuantity, totalImportWithDiscount, totalImportWithoutDiscount, totalImporTaxes, totalDiscountAmount, totalSubtotalAmount, taxBreakdown, totalNetAfterDiscount, totalGrossBeforeDiscount, } = getProductLineTotals(productTableImports);
+        // NOTE: the old post-tax "discountCodeAmount" subtraction was removed.
+        // NUMBER coupons (both `applyOnceOnOrder=true` and `=false`) are now
+        // applied pre-tax via per-line `discountAmount` baked above, so
+        // `totalImportWithDiscount` already reflects the coupon AND its tax
+        // reduction effect. `totalDiscountAmount` from the line totals is the
+        // nominal coupon value (user-facing "Descuento").
         // === SHIPPING COST ===
         const shippingCost = getShippingCost(discountCodeObj, hasShippingCost, storeSettings);
         // === TOTAL ANTES DE CRÉDITOS/PUNTOS ===
         const orderTotalWithOutCredit = +(totalImportWithDiscount +
-            shippingCost -
-            discountCodeAmount).toFixed(2);
+            shippingCost).toFixed(2);
         // === APLICAR CRÉDITO Y PUNTOS REDIMIDOS ===
         const creditApplied = getCreditApplied(selectedCustomer, orderTotalWithOutCredit);
         const orderTotal = +(orderTotalWithOutCredit -
             creditApplied -
             redeemPointsDiscount).toFixed(2);
+        // === PRICING BREAKDOWN ===
+        // For included: totalImportWithoutDiscount=gross-before-discount, totalSubtotalAmount=net-before-discount
+        // For over_price: totalImportWithoutDiscount=net-before-discount, totalSubtotalAmount=net-after-discount
+        const taxMode = (storeSettings === null || storeSettings === void 0 ? void 0 : storeSettings.taxesType) === 'over_price' ? 'over_price' : 'included';
+        const subtotalBeforeDiscountNet = taxMode === 'included' ? totalSubtotalAmount : totalImportWithoutDiscount;
+        const subtotalAfterDiscountNet = taxMode === 'included' ? totalNetAfterDiscount : totalSubtotalAmount;
+        const subtotalBeforeDiscountGross = taxMode === 'included' ? totalImportWithoutDiscount : totalGrossBeforeDiscount;
+        const subtotalAfterDiscountGross = totalImportWithDiscount;
+        const pricingBreakdown = {
+            subtotalBeforeDiscountNet,
+            subtotalAfterDiscountNet,
+            subtotalBeforeDiscountGross,
+            subtotalAfterDiscountGross,
+            discountTotalNet: +(subtotalBeforeDiscountNet - subtotalAfterDiscountNet).toFixed(2),
+            discountTotalGross: +(subtotalBeforeDiscountGross - subtotalAfterDiscountGross).toFixed(2),
+            taxesTotal: totalImporTaxes,
+            shippingServiceTotal: shippingCost,
+            creditApplied,
+            redeemPointsApplied: redeemPointsDiscount,
+            totalBeforePaymentsGross: orderTotalWithOutCredit,
+            total: orderTotal,
+        };
+        // For included: non-NUMBER lineDiscountAmount is net (discountAmountPerUnit*qty), so
+        // totalDiscountAmount is mixed-semantic. Use discountTotalGross (gross-before minus gross-after)
+        // which is unambiguously user-facing in both modes.
+        const displayDiscount = taxMode === 'included' ? pricingBreakdown.discountTotalGross : pricingBreakdown.discountTotalNet;
+        const displayTotals = {
+            subtotal: totalImportWithoutDiscount, // display-safe: gross (included) or net (over_price) — both equal the price-tag amount
+            discount: displayDiscount,
+            taxesTotal: totalImporTaxes,
+            taxesLabel: taxMode === 'included' ? 'taxesIncluded' : 'taxesTotal',
+            shippingServiceTotal: shippingCost,
+            creditApplied,
+            redeemPointsApplied: redeemPointsDiscount,
+            total: orderTotal,
+        };
         // === RETURN FINAL OBJECT ===
-        return Object.assign(Object.assign({}, order), { totalQuantity, customerDiscount: order.discountCode ? 0 : (_c = selectedCustomer === null || selectedCustomer === void 0 ? void 0 : selectedCustomer.customer) === null || _c === void 0 ? void 0 : _c.discount, productTotal: totalImportWithDiscount, taxesTotal: totalImporTaxes, taxBreakdown, total: orderTotal, creditApplied, redeemPointsApplied: redeemPointsDiscount, productTotalWithoutDiscount: totalImportWithoutDiscount, totalDiscountAmount: totalDiscountAmount + discountCodeAmount, shippingServiceTotal: shippingCost, appliedOrderDiscounts, subtotal: totalSubtotalAmount });
+        return Object.assign(Object.assign({}, order), { totalQuantity, customerDiscount: order.discountCode ? 0 : (_c = selectedCustomer === null || selectedCustomer === void 0 ? void 0 : selectedCustomer.customer) === null || _c === void 0 ? void 0 : _c.discount, productTotal: totalImportWithDiscount, taxesTotal: totalImporTaxes, taxBreakdown, total: orderTotal, creditApplied, redeemPointsApplied: redeemPointsDiscount, productTotalWithoutDiscount: totalImportWithoutDiscount, totalDiscountAmount: totalDiscountAmount, shippingServiceTotal: shippingCost, appliedOrderDiscounts, subtotal: totalSubtotalAmount, pricingBreakdown,
+            displayTotals });
     }
     catch (error) {
         throw error;

package/dist/utils/orders/calculateTotalTaxesIncluded.js

@@ -92,10 +92,23 @@ export const calculateTotalTaxesIncluded = (order, selectedCustomer, storeSettin
         const unitExtraNet = qty > 0 ? extraAmountNet / qty : 0;
         // Precio neto ajustado: precio base + extra (por unidad)
         const adjustedUnitNetPrice = unitNetPrice + unitExtraNet;
-        // Calcular el descuento sobre el precio ajustado
-        const discountAmountPerUnit = discPercentageInteger ? adjustedUnitNetPrice * discPercentageInteger : 0;
+        // Calcular el descuento por unidad.
+        // - PERCENTAGE/BUY_X_GET_Y/FREE_ITEM: derive from `discPercentageInteger`
+        //   (already applied as percentage on adjusted net unit price).
+        // - NUMBER (fixed): `current.discountAmount` is the per-line GROSS
+        //   discount in pesos, baked by `applyDiscountToProducts`. Convert to
+        //   per-unit net so the existing pipeline computes tax post-discount.
+        let discountAmountPerUnit = discPercentageInteger ? adjustedUnitNetPrice * discPercentageInteger : 0;
+        const isFixedNumberCoupon = !!discountCodeObj &&
+            discountCodeObj.type === DiscountCodeTypes.NUMBER &&
+            Number(current.discountAmount) > 0;
+        if (isFixedNumberCoupon && qty > 0) {
+            const perUnitGrossDiscount = Number(current.discountAmount) / qty;
+            const perUnitNetDiscount = perUnitGrossDiscount / taxFactor;
+            discountAmountPerUnit = Math.min(adjustedUnitNetPrice, perUnitNetDiscount);
+        }
         // Precio neto con descuento aplicado por unidad
-        const discountedUnitNetPrice = adjustedUnitNetPrice - discountAmountPerUnit;
+        const discountedUnitNetPrice = Math.max(0, adjustedUnitNetPrice - discountAmountPerUnit);
         // === Totales de la línea ===
         // Total neto sin descuento: precio base total + extra (ya prorrateado en el total)
         const productNetTotalWithoutDiscount = (unitNetPrice * qty) + extraAmountNet;
@@ -111,7 +124,12 @@ export const calculateTotalTaxesIncluded = (order, selectedCustomer, storeSettin
             store: storeSettings,
             lineTaxAmount: totalTaxesApplied,
         });
-        const lineDiscount = +(discountAmountPerUnit * qty).toFixed(2);
+        // For NUMBER coupons the user-facing "Descuento" is the gross slice
+        // (which is what was baked into `current.discountAmount`). For other
+        // discount types, line discount = per-unit net × qty (existing).
+        const lineDiscount = isFixedNumberCoupon
+            ? Number(current.discountAmount)
+            : +(discountAmountPerUnit * qty).toFixed(2);
         return {
             product: current,
             qty,
@@ -120,7 +138,8 @@ export const calculateTotalTaxesIncluded = (order, selectedCustomer, storeSettin
             productLineTaxesTotal: totalTaxesApplied,
             taxBreakdown,
             lineDiscountAmount: lineDiscount,
-            productLineSubtotal: productNetTotalWithoutDiscount // Subtotal neto (sin IVA)
+            productLineSubtotal: productNetTotalWithoutDiscount, // Subtotal neto (sin IVA) — for included this is NET before discount
+            lineNetAfterDiscount: productNetTotalWithDiscount, // NET after discount — needed to derive pricingBreakdown
         };
     });
     return productTableImports;

package/dist/utils/orders/calculateTotalTaxesOverPrice.js

@@ -68,6 +68,12 @@ export const calculateTotalTaxesOverPrice = (order, selectedCustomer, storeSetti
                         : 0;
                 }
             }
+            else if (discountCodeObj.type === DiscountCodeTypes.NUMBER) {
+                // Fixed-amount discount baked by `applyDiscountToProducts` as
+                // `current.discountAmount` (line-total, NET pesos in over_price).
+                // Per-unit treatment: derive `productDiscount = discountAmount / qty`
+                // so the existing pipeline below subtracts pre-tax.
+            }
             else if (discountCodeObj.type === DiscountCodeTypes.BUY_X_GET_Y) {
                 const condition = discountCodeObj.buyAndGetConditions[0];
                 if (condition.getDiscountType === BuyAndGetConditionsTypes.PERCENTAGE && current.isBuyAndGetProduct) {
@@ -81,9 +87,19 @@ export const calculateTotalTaxesOverPrice = (order, selectedCustomer, storeSetti
                 discPercentageInteger = 1;
             }
         }
-        // Calcular el descuento por unidad sobre el precio ajustado
-        const productDiscount = adjustedPrice * discPercentageInteger;
-        const discountedAdjustedPrice = adjustedPrice - productDiscount;
+        // Calcular el descuento por unidad sobre el precio ajustado.
+        // - PERCENTAGE/BUY_X_GET_Y/FREE_ITEM: derive from `discPercentageInteger`.
+        // - NUMBER (fixed): `current.discountAmount` is the per-line NET discount
+        //   in pesos, baked by `applyDiscountToProducts`. Convert to per-unit.
+        let productDiscount = adjustedPrice * discPercentageInteger;
+        const isFixedNumberCoupon = !!discountCodeObj &&
+            discountCodeObj.type === DiscountCodeTypes.NUMBER &&
+            Number(current.discountAmount) > 0;
+        if (isFixedNumberCoupon && qty > 0) {
+            const perUnitDiscount = Number(current.discountAmount) / qty;
+            productDiscount = Math.min(adjustedPrice, perUnitDiscount);
+        }
+        const discountedAdjustedPrice = Math.max(0, adjustedPrice - productDiscount);
         // Subtotal para la línea (precio descontado por unidad * cantidad) SIN impuestos
         const subtotal = discountedAdjustedPrice * qty;
         // Calcular impuestos sobre el subtotal
@@ -99,18 +115,21 @@ export const calculateTotalTaxesOverPrice = (order, selectedCustomer, storeSetti
         const lineDiscount = +(productDiscount * qty).toFixed(2);
         // Precio total con descuento, reaplicando impuestos
         const prodLinePriceWithDiscount = +((subtotal * (1 + taxPercentage))).toFixed(2);
+        // GROSS before discount: net-before-discount * (1 + tax). Needed to derive pricingBreakdown.
+        const lineGrossBeforeDiscount = +((productBasePrice * qty + extraAmount) * (1 + taxPercentage)).toFixed(2);
         return {
             product: current,
             qty,
-            // Total bruto original sin descuento: (precio base * cantidad) + extraAmount
+            // Total neto original sin descuento: (precio base * cantidad) + extraAmount
             productLineImportTotal: (productBasePrice * qty) + extraAmount,
             // Total final con descuento, con impuestos incluidos
             productLineTotalWithDiscount: prodLinePriceWithDiscount,
             productLineTaxesTotal: totalTaxesApplied,
             taxBreakdown,
             lineDiscountAmount: lineDiscount,
-            // Subtotal neto (sin impuestos) con descuento aplicado
-            productLineSubtotal: subtotal
+            // Subtotal neto (sin impuestos) con descuento aplicado — for over_price this is NET after discount
+            productLineSubtotal: subtotal,
+            lineGrossBeforeDiscount, // GROSS before discount — needed to derive pricingBreakdown
         };
     });
     return productTableImports;

package/dist/utils/orders/helpers.js

@@ -110,7 +110,7 @@ const getApplicableTaxesForProduct = (productObj, store) => {
         return acc;
     }, []);
 };
-const allocateByWeights = (total, weights) => {
+export const allocateByWeights = (total, weights) => {
     if (weights.length === 0)
         return [];
     if (total <= 0)
@@ -132,6 +132,43 @@ const allocateByWeights = (total, weights) => {
     }
     return out;
 };
+// Allocate a fixed order-level discount across eligible line bases (in cents).
+// Each entry is capped at its corresponding base. Overflow caused by the cap
+// is rerouted to the next-largest base. The result sums to
+// min(totalCents, sum(baseCents)).
+export const allocateFixedDiscountAcrossLines = (totalCents, baseCents) => {
+    const len = baseCents.length;
+    if (len === 0)
+        return [];
+    const safeBases = baseCents.map((b) => Math.max(0, Math.trunc(b)));
+    const sumBases = safeBases.reduce((a, b) => a + b, 0);
+    if (sumBases <= 0 || totalCents <= 0) {
+        return new Array(len).fill(0);
+    }
+    const cappedTotal = Math.min(Math.trunc(totalCents), sumBases);
+    const slices = allocateByWeights(cappedTotal, safeBases);
+    let overflow = 0;
+    for (let i = 0; i < len; i += 1) {
+        if (slices[i] > safeBases[i]) {
+            overflow += slices[i] - safeBases[i];
+            slices[i] = safeBases[i];
+        }
+    }
+    if (overflow === 0)
+        return slices;
+    const headroomOrder = safeBases
+        .map((b, i) => ({ i, headroom: b - slices[i] }))
+        .filter((entry) => entry.headroom > 0)
+        .sort((a, b) => b.headroom - a.headroom);
+    for (const entry of headroomOrder) {
+        if (overflow <= 0)
+            break;
+        const take = Math.min(entry.headroom, overflow);
+        slices[entry.i] += take;
+        overflow -= take;
+    }
+    return slices;
+};
 export const aggregateTaxBreakdown = (items) => {
     const byKey = new Map();
     items.forEach((item) => {
@@ -199,6 +236,14 @@ export const getProductLineTotals = (productLinesTotals) => {
         .reduce((acum, line) => acum + line.productLineSubtotal, 0)
         .toFixed(2);
     const taxBreakdown = normalizeTaxBreakdownToTotal(productLinesTotals.flatMap((line) => line.taxBreakdown || []), totalImporTaxes);
+    // lineNetAfterDiscount is set by the included calculator (for over_price, productLineSubtotal IS net-after-discount)
+    // lineGrossBeforeDiscount is set by the over_price calculator (for included, productLineImportTotal IS gross-before-discount)
+    const totalNetAfterDiscount = +productLinesTotals
+        .reduce((acum, line) => { var _a; return acum + ((_a = line.lineNetAfterDiscount) !== null && _a !== void 0 ? _a : line.productLineSubtotal); }, 0)
+        .toFixed(2);
+    const totalGrossBeforeDiscount = +productLinesTotals
+        .reduce((acum, line) => { var _a; return acum + ((_a = line.lineGrossBeforeDiscount) !== null && _a !== void 0 ? _a : line.productLineImportTotal); }, 0)
+        .toFixed(2);
     return {
         totalQuantity,
         totalImportWithDiscount,
@@ -206,7 +251,9 @@ export const getProductLineTotals = (productLinesTotals) => {
         totalImporTaxes,
         totalDiscountAmount,
         totalSubtotalAmount,
-        taxBreakdown
+        taxBreakdown,
+        totalNetAfterDiscount,
+        totalGrossBeforeDiscount,
     };
 };
 export const getShippingCost = (discountObject, requireShippingService, store) => {
@@ -296,21 +343,54 @@ export const applyDiscountToProducts = (discountCode, productsArr, isExpress, st
         }
     }
     if (discountCode && discountCode.type === DiscountCodeTypes.NUMBER) {
-        const discountAmount = discountCode.value;
-        if (!discountCode.applyOnceOnOrder) {
-            if (discountCode.applyToAllProducts) {
-                newOrderProds = newOrderProds.map((prod) => (Object.assign(Object.assign({}, prod), { discountAmount: discountAmount })));
-            }
-            else {
-                const discountProductIds = getTargetProductIdSet(discountCode.products);
-                newOrderProds = newOrderProds.map((prod) => {
-                    if (!discountProductIds.has(getProductIdentity(prod))) {
-                        return prod;
-                    }
-                    return Object.assign(Object.assign({}, prod), { discountAmount });
+        const couponValue = Number(discountCode.value) || 0;
+        const eligibilityIds = discountCode.applyToAllProducts
+            ? null
+            : getTargetProductIdSet(discountCode.products);
+        const isEligibleProd = (prod) => eligibilityIds === null || eligibilityIds.has(getProductIdentity(prod));
+        if (discountCode.applyOnceOnOrder) {
+            // applyOnceOnOrder=true: allocate the fixed amount proportionally
+            // across eligible lines so each line carries its share as a pre-tax
+            // discountAmount. The downstream tax calc reads this and reduces the
+            // taxable base before computing tax.
+            const eligibleEntries = [];
+            newOrderProds.forEach((prod, idx) => {
+                var _a, _b;
+                if (!isEligibleProd(prod))
+                    return;
+                const prodPrice = isExpress
+                    ? (_a = prod.expressPrice) !== null && _a !== void 0 ? _a : prod.price
+                    : prod.price;
+                const qty = Number((_b = prod.qty) !== null && _b !== void 0 ? _b : prod.quantity) || 0;
+                const extra = Number(prod.extraAmount) || 0;
+                const baseCents = Math.round(((Number(prodPrice) || 0) * qty + extra) * 100);
+                if (baseCents > 0) {
+                    eligibleEntries.push({ idx, baseCents });
+                }
+            });
+            if (eligibleEntries.length > 0) {
+                const couponCents = Math.max(0, Math.round(couponValue * 100));
+                const sliceCents = allocateFixedDiscountAcrossLines(couponCents, eligibleEntries.map((e) => e.baseCents));
+                const newProdsCopy = newOrderProds.slice();
+                eligibleEntries.forEach((e, i) => {
+                    const slicePesos = +(sliceCents[i] / 100).toFixed(2);
+                    newProdsCopy[e.idx] = Object.assign(Object.assign({}, newProdsCopy[e.idx]), { discountAmount: slicePesos });
                 });
+                newOrderProds = newProdsCopy;
             }
         }
+        else {
+            // applyOnceOnOrder=false: per-unit fixed discount. Total per eligible
+            // line is value * qty (was a flat `value` previously — silent bug).
+            newOrderProds = newOrderProds.map((prod) => {
+                var _a;
+                if (!isEligibleProd(prod))
+                    return prod;
+                const qty = Number((_a = prod.qty) !== null && _a !== void 0 ? _a : prod.quantity) || 0;
+                const lineDiscount = +(couponValue * qty).toFixed(2);
+                return Object.assign(Object.assign({}, prod), { discountAmount: lineDiscount });
+            });
+        }
     }
     if (discountCode.buyAndGetConditions && discountCode.type === DiscountCodeTypes.BUY_X_GET_Y) {
         const buyConditions = discountCode.buyAndGetConditions[0].buyConditions;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "washday-sdk",
-  "version": "1.6.70",
+  "version": "1.6.72",
   "description": "Washday utilities functions and API",
   "main": "dist/index.js",
   "type": "module",

package/src/interfaces/Product.ts

@@ -13,6 +13,10 @@ export interface ProductLineTotals {
     taxBreakdown?: ITaxBreakdownItem[],
     lineDiscountAmount: number
     productLineSubtotal: number
+    // Additive semantic fields. Only the calculator that can compute these natively sets them;
+    // the other mode's fallback is encoded in getProductLineTotals.
+    lineNetAfterDiscount?: number   // set by included calculator; for over_price productLineSubtotal already IS net-after-discount
+    lineGrossBeforeDiscount?: number // set by over_price calculator; for included productLineImportTotal already IS gross-before-discount
 }
 
 export interface IPriceOption {

package/src/utils/orders/calculateOrderTotal.test.js

@@ -926,5 +926,169 @@ describe("Calculate Order Total tests", () => {
   });
 
   
+  // ─── pricingBreakdown ───────────────────────────────────────────────────
+
+  it("pricingBreakdown: included, no discount — legacy fields unchanged, breakdown correct", () => {
+    ORDER_DEMO.store.taxesType = "included";
+    const { orderDto, customer, store, storeDiscounts, discountCodeObj } = ORDER_DEMO;
+    const result = calculateOrderTotal(orderDto, { customer }, store, false, storeDiscounts, discountCodeObj);
+
+    // Legacy fields must be preserved
+    expect(result.productTotal).toBe(54.22);
+    expect(result.productTotalWithoutDiscount).toBe(54.22);
+    expect(result.taxesTotal).toBe(8.68);
+    expect(result.subtotal).toBeCloseTo(46.74, 1); // net before discount for included
+
+    const bd = result.pricingBreakdown;
+    expect(bd.subtotalBeforeDiscountGross).toBe(54.22);
+    expect(bd.subtotalAfterDiscountGross).toBe(54.22);
+    expect(bd.discountTotalGross).toBe(0);
+    expect(bd.discountTotalNet).toBeCloseTo(0, 1);
+    expect(bd.taxesTotal).toBe(8.68);
+    expect(bd.totalBeforePaymentsGross).toBe(54.22);
+    expect(bd.total).toBeCloseTo(result.total, 2);
+
+    const dt = result.displayTotals;
+    expect(dt.subtotal).toBe(54.22);
+    expect(dt.taxesLabel).toBe("taxesIncluded");
+    expect(dt.total).toBeCloseTo(result.total, 2);
+  });
+
+  it("pricingBreakdown: over_price, no discount — legacy fields unchanged, breakdown correct", () => {
+    ORDER_DEMO.store.taxesType = "over_price";
+    const { orderDto, customer, store, storeDiscounts, discountCodeObj } = ORDER_DEMO;
+    const result = calculateOrderTotal(orderDto, { customer }, store, false, storeDiscounts, discountCodeObj);
+
+    // product: price=17, qty=3.7, tax=16% over_price
+    // net before discount = 17 * 3.7 = 62.9
+    // gross before discount = 62.9 * 1.16 = 72.964 ≈ 72.96
+    expect(result.productTotal).toBeCloseTo(72.96, 1);
+    expect(result.productTotalWithoutDiscount).toBeCloseTo(62.9, 2);
+
+    const bd = result.pricingBreakdown;
+    expect(bd.subtotalBeforeDiscountNet).toBeCloseTo(62.9, 2);
+    expect(bd.subtotalAfterDiscountNet).toBeCloseTo(62.9, 2);
+    expect(bd.subtotalBeforeDiscountGross).toBeCloseTo(72.96, 1);
+    expect(bd.subtotalAfterDiscountGross).toBeCloseTo(72.96, 1);
+    expect(bd.discountTotalNet).toBe(0);
+    expect(bd.discountTotalGross).toBeCloseTo(0, 1);
+
+    const dt = result.displayTotals;
+    expect(dt.subtotal).toBeCloseTo(62.9, 2); // net (= price tag for over_price)
+    expect(dt.taxesLabel).toBe("taxesTotal");
+  });
+
+  it("pricingBreakdown: included + NUMBER coupon $30 on $50 product (acceptance criteria issue#40)", () => {
+    // Setup: product price=$50 gross (tax=16% included), qty=1, NUMBER coupon=$30
+    ORDER_DEMO.store.taxesType = "included";
+    ORDER_DEMO.orderDto.products = [{
+      _id: "prod1",
+      name: "Test",
+      price: 50,
+      expressPrice: 50,
+      qty: 1,
+      quantity: 1,
+      extraAmount: 0,
+      taxExemptOne: false, taxExemptTwo: false, taxExemptThree: false,
+      discountAmount: 0,
+    }];
+    ORDER_DEMO.orderDto.buyAndGetProducts = [];
+    ORDER_DEMO.orderDto.discountCode = "THIRTY";
+    ORDER_DEMO.discountCodeObj = {
+      _id: "dc1",
+      type: "number",
+      value: 30,
+      applyToAllProducts: true,
+      applyOnceOnOrder: true,
+      products: [],
+      freeProductSetting: [],
+      buyAndGetConditions: [],
+    };
+
+    const { orderDto, customer, store, storeDiscounts } = ORDER_DEMO;
+    const result = calculateOrderTotal(orderDto, { customer }, store, false, storeDiscounts, ORDER_DEMO.discountCodeObj);
+
+    // gross before discount = 50, NUMBER $30 applied pre-tax
+    // net before discount = 50/1.16 ≈ 43.10
+    // gross after discount = 50 - 30 = 20
+    // tax on $20 gross = 20 - 20/1.16 ≈ 2.76
+    expect(result.productTotalWithoutDiscount).toBe(50);      // gross-before-discount (display subtotal)
+    expect(result.productTotal).toBeCloseTo(20, 1);           // gross-after-discount
+    expect(result.totalDiscountAmount).toBe(30);              // user-facing discount
+    expect(result.taxesTotal).toBeCloseTo(2.76, 1);
+    expect(result.total).toBeCloseTo(20, 1);
+
+    const bd = result.pricingBreakdown;
+    expect(bd.subtotalBeforeDiscountGross).toBe(50);
+    expect(bd.subtotalAfterDiscountGross).toBeCloseTo(20, 1);
+    expect(bd.discountTotalGross).toBeCloseTo(30, 1);
+    expect(bd.subtotalBeforeDiscountNet).toBeCloseTo(43.1, 1);
+    expect(bd.subtotalAfterDiscountNet).toBeCloseTo(17.24, 1);
+    expect(bd.discountTotalNet).toBeCloseTo(25.86, 1);
+    expect(bd.taxesTotal).toBeCloseTo(2.76, 1);
+    expect(bd.totalBeforePaymentsGross).toBeCloseTo(20, 1);
+    expect(bd.total).toBeCloseTo(20, 1);
+
+    const dt = result.displayTotals;
+    expect(dt.subtotal).toBe(50);
+    expect(dt.discount).toBe(30);
+    expect(dt.taxesLabel).toBe("taxesIncluded");
+    expect(dt.total).toBeCloseTo(20, 1);
+  });
+
+  it("pricingBreakdown: over_price + NUMBER coupon $30 on $50 product (acceptance criteria issue#40)", () => {
+    ORDER_DEMO.store.taxesType = "over_price";
+    ORDER_DEMO.orderDto.products = [{
+      _id: "prod1",
+      name: "Test",
+      price: 50,
+      expressPrice: 50,
+      qty: 1,
+      quantity: 1,
+      extraAmount: 0,
+      taxExemptOne: false, taxExemptTwo: false, taxExemptThree: false,
+      discountAmount: 0,
+    }];
+    ORDER_DEMO.orderDto.buyAndGetProducts = [];
+    ORDER_DEMO.orderDto.discountCode = "THIRTY";
+    ORDER_DEMO.discountCodeObj = {
+      _id: "dc1",
+      type: "number",
+      value: 30,
+      applyToAllProducts: true,
+      applyOnceOnOrder: true,
+      products: [],
+      freeProductSetting: [],
+      buyAndGetConditions: [],
+    };
+
+    const { orderDto, customer, store, storeDiscounts } = ORDER_DEMO;
+    const result = calculateOrderTotal(orderDto, { customer }, store, false, storeDiscounts, ORDER_DEMO.discountCodeObj);
+
+    // net before discount = 50; NUMBER $30 net; net after discount = 20
+    // tax = 20 * 0.16 = 3.20; total = 23.20
+    expect(result.productTotalWithoutDiscount).toBe(50);      // net-before-discount (display subtotal for over_price)
+    expect(result.totalDiscountAmount).toBe(30);
+    expect(result.taxesTotal).toBeCloseTo(3.2, 1);
+    expect(result.total).toBeCloseTo(23.2, 1);
+
+    const bd = result.pricingBreakdown;
+    expect(bd.subtotalBeforeDiscountNet).toBe(50);
+    expect(bd.subtotalAfterDiscountNet).toBeCloseTo(20, 1);
+    expect(bd.discountTotalNet).toBeCloseTo(30, 1);
+    expect(bd.subtotalBeforeDiscountGross).toBeCloseTo(58, 1);  // 50 * 1.16
+    expect(bd.subtotalAfterDiscountGross).toBeCloseTo(23.2, 1); // 20 * 1.16
+    expect(bd.discountTotalGross).toBeCloseTo(34.8, 1);         // 30 * 1.16
+    expect(bd.taxesTotal).toBeCloseTo(3.2, 1);
+    expect(bd.totalBeforePaymentsGross).toBeCloseTo(23.2, 1);
+    expect(bd.total).toBeCloseTo(23.2, 1);
+
+    const dt = result.displayTotals;
+    expect(dt.subtotal).toBe(50);  // net = display price for over_price
+    expect(dt.discount).toBe(30);
+    expect(dt.taxesLabel).toBe("taxesTotal");
+    expect(dt.total).toBeCloseTo(23.2, 1);
+  });
+
   // Add more test cases as needed
 });