washday-sdk 1.6.70 → 1.6.71

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,43 @@ 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;
-        }
+        // 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);
         // === 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 });
     }
     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,

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

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) => {
@@ -296,21 +333,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.71",
   "description": "Washday utilities functions and API",
   "main": "dist/index.js",
   "type": "module",

package/src/utils/orders/calculateOrderTotal.ts

@@ -3,7 +3,12 @@ import { ICustomer } from "../../interfaces/Customer";
 import { IStore } from "../../interfaces/Store";
 import { calculateTotalTaxesIncluded } from "./calculateTotalTaxesIncluded";
 import { calculateTotalTaxesOverPrice } from "./calculateTotalTaxesOverPrice";
-import { getCreditApplied, getProductLineTotals, getShippingCost } from "./helpers";
+import {
+  applyDiscountToProducts,
+  getCreditApplied,
+  getProductLineTotals,
+  getShippingCost,
+} from "./helpers";
 
 const getNormalizedId = (value: any): string => {
   if (value === null || value === undefined) {
@@ -54,13 +59,38 @@ export const calculateOrderTotal = (
   try {
     const appliedOrderDiscounts: any = {};
 
+    // 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,
+        order.products ?? [],
+        Boolean(order.express),
+        storeDiscounts,
+        selectedCustomer?.customer
+      );
+      processedOrder = {
+        ...order,
+        products: newOrderProds,
+        buyAndGetProducts:
+          buyAndGetProds && buyAndGetProds.length > 0
+            ? buyAndGetProds
+            : order.buyAndGetProducts ?? [],
+      };
+    }
+
     const productTableCalculator =
       storeSettings?.taxesType === 'over_price'
         ? calculateTotalTaxesOverPrice
         : calculateTotalTaxesIncluded;
 
     const productTableImports = productTableCalculator(
-      order,
+      processedOrder,
       selectedCustomer,
       storeSettings,
       storeDiscounts,
@@ -79,27 +109,12 @@ export const calculateOrderTotal = (
       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: any) =>
-          hasMatchingDiscountTarget(discountCodeObj.products, curr)
-        );
-
-      const minimumOrderSubtotal = Number(discountCodeObj.minimumOrderSubtotal ?? 0);
-      const meetsMinimum =
-        !Number.isFinite(minimumOrderSubtotal) ||
-        minimumOrderSubtotal <= 0 ||
-        Number(totalImportWithoutDiscount ?? totalSubtotalAmount ?? 0) >= minimumOrderSubtotal;
-
-      discountCodeAmount = includesProducts && meetsMinimum ? discountCodeObj.value : 0;
-    }
+    // 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(
@@ -111,8 +126,7 @@ export const calculateOrderTotal = (
     // === TOTAL ANTES DE CRÉDITOS/PUNTOS ===
     const orderTotalWithOutCredit = +(
       totalImportWithDiscount +
-      shippingCost -
-      discountCodeAmount
+      shippingCost
     ).toFixed(2);
 
     // === APLICAR CRÉDITO Y PUNTOS REDIMIDOS ===
@@ -139,7 +153,7 @@ export const calculateOrderTotal = (
       creditApplied,
       redeemPointsApplied: redeemPointsDiscount, // ✅ NUEVO CAMPO
       productTotalWithoutDiscount: totalImportWithoutDiscount,
-      totalDiscountAmount: totalDiscountAmount + discountCodeAmount,
+      totalDiscountAmount: totalDiscountAmount,
       shippingServiceTotal: shippingCost,
       appliedOrderDiscounts,
       subtotal: totalSubtotalAmount

package/src/utils/orders/calculateTotalTaxesIncluded.ts

@@ -107,10 +107,26 @@ export const calculateTotalTaxesIncluded = (
     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)
@@ -130,7 +146,12 @@ export const calculateTotalTaxesIncluded = (
       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,

package/src/utils/orders/calculateTotalTaxesOverPrice.ts

@@ -81,6 +81,11 @@ export const calculateTotalTaxesOverPrice = (
             ? +(discountCodeObj.value / 100).toFixed(2)
             : 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) {
@@ -94,9 +99,20 @@ export const calculateTotalTaxesOverPrice = (
       }
     }
 
-    // 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;

package/src/utils/orders/helpers.ts

@@ -151,7 +151,7 @@ const getApplicableTaxesForProduct = (
   }, []);
 };
 
-const allocateByWeights = (total: number, weights: number[]): number[] => {
+export const allocateByWeights = (total: number, weights: number[]): number[] => {
   if (weights.length === 0) return [];
   if (total <= 0) return new Array(weights.length).fill(0);
 
@@ -174,6 +174,47 @@ const allocateByWeights = (total: number, weights: number[]): number[] => {
   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: number,
+  baseCents: number[]
+): number[] => {
+  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: ITaxBreakdownItem[]
 ): ITaxBreakdownItem[] => {
@@ -400,19 +441,56 @@ export const applyDiscountToProducts = (
   }
 
   if (discountCode && discountCode.type === DiscountCodeTypes.NUMBER) {
-    const discountAmount = discountCode.value;
-    if (!discountCode.applyOnceOnOrder) {
-      if (discountCode.applyToAllProducts) {
-        newOrderProds = newOrderProds.map((prod: any) => ({ ...prod, discountAmount: discountAmount }));
-      } else {
-        const discountProductIds = getTargetProductIdSet(discountCode.products);
-        newOrderProds = newOrderProds.map((prod: any) => {
-          if (!discountProductIds.has(getProductIdentity(prod))) {
-            return prod;
-          }
-          return { ...prod, discountAmount };
+    const couponValue = Number(discountCode.value) || 0;
+    const eligibilityIds: Set<string> | null = discountCode.applyToAllProducts
+      ? null
+      : getTargetProductIdSet(discountCode.products);
+    const isEligibleProd = (prod: any) =>
+      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: { idx: number; baseCents: number }[] = [];
+      newOrderProds.forEach((prod: any, idx: number) => {
+        if (!isEligibleProd(prod)) return;
+        const prodPrice = isExpress
+          ? prod.expressPrice ?? prod.price
+          : prod.price;
+        const qty = Number(prod.qty ?? 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] = { ...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: any) => {
+        if (!isEligibleProd(prod)) return prod;
+        const qty = Number(prod.qty ?? prod.quantity) || 0;
+        const lineDiscount = +(couponValue * qty).toFixed(2);
+        return { ...prod, discountAmount: lineDiscount };
+      });
     }
   }
 

package/test/orders.allocator.test.ts

@@ -0,0 +1,58 @@
+import {
+  allocateByWeights,
+  allocateFixedDiscountAcrossLines
+} from "../src/utils/orders/helpers";
+
+describe("allocateByWeights (SDK)", () => {
+  it("returns empty for empty weights", () => {
+    expect(allocateByWeights(100, [])).toEqual([]);
+  });
+
+  it("returns zeros when total is non-positive", () => {
+    expect(allocateByWeights(0, [10, 20])).toEqual([0, 0]);
+  });
+
+  it("returns zeros when all weights are zero", () => {
+    expect(allocateByWeights(100, [0, 0, 0])).toEqual([0, 0, 0]);
+  });
+
+  it("distributes evenly when weights are equal", () => {
+    expect(allocateByWeights(100, [10, 10])).toEqual([50, 50]);
+  });
+
+  it("sums to total across uneven weights", () => {
+    const total = 1000;
+    const result = allocateByWeights(total, [3, 5, 7, 11]);
+    expect(result.reduce((a, b) => a + b, 0)).toBe(total);
+  });
+});
+
+describe("allocateFixedDiscountAcrossLines (SDK)", () => {
+  it("returns empty for no bases", () => {
+    expect(allocateFixedDiscountAcrossLines(500, [])).toEqual([]);
+  });
+
+  it("returns zeros when total is zero", () => {
+    expect(allocateFixedDiscountAcrossLines(0, [100, 200])).toEqual([0, 0]);
+  });
+
+  it("caps at sum of bases when total exceeds it", () => {
+    expect(allocateFixedDiscountAcrossLines(10000, [3000, 2000])).toEqual([3000, 2000]);
+  });
+
+  it("never exceeds a single line's base, reroutes overflow", () => {
+    const result = allocateFixedDiscountAcrossLines(5000, [100, 100000]);
+    expect(result[0]).toBeLessThanOrEqual(100);
+    expect(result[1]).toBeLessThanOrEqual(100000);
+    expect(result.reduce((a, b) => a + b, 0)).toBe(5000);
+  });
+
+  it("distributes proportionally to bases", () => {
+    expect(allocateFixedDiscountAcrossLines(1000, [3000, 7000])).toEqual([300, 700]);
+  });
+
+  it("handles a single line", () => {
+    expect(allocateFixedDiscountAcrossLines(500, [1000])).toEqual([500]);
+    expect(allocateFixedDiscountAcrossLines(2000, [1000])).toEqual([1000]);
+  });
+});

package/test/orders.discountCodeNumberPreTax.test.ts

@@ -0,0 +1,217 @@
+import { utils } from "../src";
+
+const baseSelectedCustomer = {
+  customer: { credit: 0, discount: 0 },
+};
+
+const buildStore = (taxesType: "over_price" | "included") => ({
+  taxesType,
+  taxOne: { name: "IVA", value: 16 },
+  taxTwo: null,
+  taxThree: null,
+  orderPageConfig: { shippingServiceCost: 0 },
+});
+
+describe("SDK calculateOrderTotal — NUMBER discount codes apply pre-tax", () => {
+  describe("over_price", () => {
+    const store = buildStore("over_price");
+
+    it("canonical case: $50 + $30 once-on-order + 16% → $23.20 total", () => {
+      const order = {
+        express: false,
+        products: [
+          { _id: "A", qty: 1, quantity: 1, price: 50, expressPrice: 50, extraAmount: 0 },
+        ],
+        buyAndGetProducts: [],
+        discountCode: "code-123",
+      };
+      const discountCode = {
+        type: "number",
+        value: 30,
+        applyToAllProducts: true,
+        applyOnceOnOrder: true,
+        products: [],
+      };
+
+      const result = utils.calculateOrderTotal(
+        order as any,
+        baseSelectedCustomer as any,
+        store as any,
+        false,
+        [],
+        discountCode,
+        0
+      );
+
+      expect(result.total).toBe(23.2);
+      expect(result.totalDiscountAmount).toBe(30);
+      expect(result.taxesTotal).toBeCloseTo(3.2, 2);
+    });
+
+    it("caps the discount at the eligible base", () => {
+      const order = {
+        express: false,
+        products: [
+          { _id: "A", qty: 1, quantity: 1, price: 20, expressPrice: 20, extraAmount: 0 },
+        ],
+        buyAndGetProducts: [],
+        discountCode: "code-123",
+      };
+      const discountCode = {
+        type: "number",
+        value: 50,
+        applyToAllProducts: true,
+        applyOnceOnOrder: true,
+        products: [],
+      };
+
+      const result = utils.calculateOrderTotal(
+        order as any,
+        baseSelectedCustomer as any,
+        store as any,
+        false,
+        [],
+        discountCode,
+        0
+      );
+
+      expect(result.total).toBe(0);
+    });
+
+    it("applyOnceOnOrder=false: per-unit fixed discount", () => {
+      const order = {
+        express: false,
+        products: [
+          { _id: "A", qty: 2, quantity: 2, price: 50, expressPrice: 50, extraAmount: 0 },
+        ],
+        buyAndGetProducts: [],
+        discountCode: "code-123",
+      };
+      const discountCode = {
+        type: "number",
+        value: 10,
+        applyToAllProducts: true,
+        applyOnceOnOrder: false,
+        products: [],
+      };
+
+      const result = utils.calculateOrderTotal(
+        order as any,
+        baseSelectedCustomer as any,
+        store as any,
+        false,
+        [],
+        discountCode,
+        0
+      );
+
+      // line base net: 100; per-unit discount $10 × qty 2 = $20 line discount
+      // net after: 80; tax 16% = 12.80; total = 92.80
+      expect(result.total).toBe(92.8);
+      expect(result.totalDiscountAmount).toBe(20);
+    });
+
+    it("distributes proportionally across multiple eligible lines (once-on-order)", () => {
+      const order = {
+        express: false,
+        products: [
+          { _id: "A", qty: 1, quantity: 1, price: 30, expressPrice: 30, extraAmount: 0 },
+          { _id: "B", qty: 1, quantity: 1, price: 70, expressPrice: 70, extraAmount: 0 },
+        ],
+        buyAndGetProducts: [],
+        discountCode: "code-123",
+      };
+      const discountCode = {
+        type: "number",
+        value: 30,
+        applyToAllProducts: true,
+        applyOnceOnOrder: true,
+        products: [],
+      };
+
+      const result = utils.calculateOrderTotal(
+        order as any,
+        baseSelectedCustomer as any,
+        store as any,
+        false,
+        [],
+        discountCode,
+        0
+      );
+
+      // 30%/70% slice → [9, 21]. Net after: 21, 49. Tax: 3.36, 7.84 → 11.20.
+      // Total = 21 + 49 + 11.20 = 81.20.
+      expect(result.total).toBe(81.2);
+      expect(result.totalDiscountAmount).toBe(30);
+    });
+  });
+
+  describe("included", () => {
+    const store = buildStore("included");
+
+    it("canonical case: $50 (gross) + $30 once-on-order + 16% included → $20 total", () => {
+      const order = {
+        express: false,
+        products: [
+          { _id: "A", qty: 1, quantity: 1, price: 50, expressPrice: 50, extraAmount: 0 },
+        ],
+        buyAndGetProducts: [],
+        discountCode: "code-123",
+      };
+      const discountCode = {
+        type: "number",
+        value: 30,
+        applyToAllProducts: true,
+        applyOnceOnOrder: true,
+        products: [],
+      };
+
+      const result = utils.calculateOrderTotal(
+        order as any,
+        baseSelectedCustomer as any,
+        store as any,
+        false,
+        [],
+        discountCode,
+        0
+      );
+
+      expect(result.total).toBe(20);
+      expect(result.totalDiscountAmount).toBe(30);
+    });
+  });
+
+  describe("regression: percentage coupons untouched", () => {
+    const store = buildStore("over_price");
+
+    it("PERCENTAGE 10% on $100 + 16% → $104.40", () => {
+      const order = {
+        express: false,
+        products: [
+          { _id: "A", qty: 1, quantity: 1, price: 100, expressPrice: 100, extraAmount: 0 },
+        ],
+        buyAndGetProducts: [],
+        discountCode: "code-123",
+      };
+      const discountCode = {
+        type: "percentage",
+        value: 10,
+        applyToAllProducts: true,
+        applyOnceOnOrder: false,
+        products: [],
+      };
+
+      const result = utils.calculateOrderTotal(
+        order as any,
+        baseSelectedCustomer as any,
+        store as any,
+        false,
+        [],
+        discountCode,
+        0
+      );
+
+      expect(result.total).toBe(104.4);
+    });
+  });
+});

package/test/orders.discountCodeOnceOnOrderAndMinimum.test.ts

@@ -52,10 +52,10 @@ describe("calculateOrderTotal — fixed-amount coupons", () => {
       0
     );
 
-    // baseline (no coupon): 5*100=500 subtotal, +16% taxes over_price = 580.
-    // once-on-order applies a flat $20 reduction to the order total only.
-    expect(result.total).toBe(560);
-    // discount is order-level, not per-line, so totalDiscountAmount keeps the once-on-order $20.
+    // Pre-tax fix: coupon $20 reduces the taxable base BEFORE taxes are
+    // computed. net 500 - 20 = 480, tax 16% = 76.80, total = 556.80.
+    // The user-facing "Descuento" remains $20 (the nominal coupon value).
+    expect(result.total).toBe(556.8);
     expect(result.totalDiscountAmount).toBe(20);
   });
 
@@ -106,8 +106,9 @@ describe("calculateOrderTotal — fixed-amount coupons", () => {
       0
     );
 
-    // 250 == 250 → discount applied. Baseline 290, minus $50 = 240.
-    expect(result.total).toBe(240);
+    // 250 == 250 → discount applied. Pre-tax fix: net 250 - 50 = 200,
+    // tax 16% = 32, total = 232.
+    expect(result.total).toBe(232);
   });
 
   it("zero/undefined minimumOrderSubtotal keeps current behavior (backwards compatible)", () => {
@@ -131,7 +132,8 @@ describe("calculateOrderTotal — fixed-amount coupons", () => {
       0
     );
 
-    expect(result.total).toBe(240);
+    // Pre-tax fix: same as the above minimum-met case → 232.
+    expect(result.total).toBe(232);
   });
 });