@wtree/payload-ecommerce-coupon 3.78.8 → 3.78.9

package/dist/index.mjs

@@ -720,14 +720,6 @@ const createReferralProgramsCollection = (pluginConfig) => {
 		timestamps: true
 	};
 };
-//#endregion
-//#region src/utilities/roundTo2.ts
-/**
-* Rounds a number to 2 decimal places (standard for monetary values).
-*/
-function roundTo2(value) {
-	return Math.round(value * 100) / 100;
-}
 function normalizeCurrencyCode(currencyCode) {
 	if (!currencyCode) return "AED";
 	return currencyCode.toUpperCase();
@@ -763,16 +755,35 @@ function getCartItemUnitPrice({ item, product, variant, currencyCode, defaultCur
 }
 //#endregion
 //#region src/utilities/calculateValues.ts
+/** Convert a normal-currency amount to integer cents. */
+function toCents(amount) {
+	return Math.round(amount * 100);
+}
+/** Convert integer cents back to a normal-currency amount (2 dp max). */
+function fromCents(cents) {
+	return Math.round(cents) / 100;
+}
+/**
+* Calculate the discount amount for a coupon.
+*
+* @param coupon    - Coupon document from DB (values in normal currency).
+* @param cartTotal - Cart subtotal in normal currency.
+* @returns Discount amount in normal currency (2 dp).
+*/
 function calculateCouponDiscount({ coupon, cartTotal }) {
-	let discount = 0;
+	const cartCents = toCents(cartTotal);
+	let discountCents = 0;
 	if (coupon.type === "percentage") {
-		discount = roundTo2(cartTotal * coupon.value / 100);
-		if (coupon.maxDiscountAmount != null && discount > coupon.maxDiscountAmount) discount = roundTo2(coupon.maxDiscountAmount);
+		discountCents = Math.floor(cartCents * coupon.value / 100);
+		if (coupon.maxDiscountAmount != null) {
+			const maxCents = toCents(coupon.maxDiscountAmount);
+			if (discountCents > maxCents) discountCents = maxCents;
+		}
 	} else if (coupon.type === "fixed") {
-		discount = roundTo2(coupon.value);
-		if (discount > cartTotal) discount = roundTo2(cartTotal);
+		discountCents = toCents(coupon.value);
+		if (discountCents > cartCents) discountCents = cartCents;
 	}
-	return roundTo2(discount);
+	return fromCents(discountCents);
 }
 function relationId$5(value) {
 	if (value == null) return null;
@@ -793,19 +804,25 @@ function getRuleSplits(rule) {
 		customerSplit: typeof rule.customerSplit === "number" ? rule.customerSplit : typeof rule.refereeSplit === "number" ? rule.refereeSplit : 100 - partnerRaw
 	};
 }
-function calculateItemRewardByRule({ rule, itemTotal, quantity, allowedTotalCommissionTypes }) {
+/**
+* Calculate partner and customer reward for a single line item.
+*
+* ALL inputs are expected in CENTS.
+* Returns rewards in CENTS, or null if the rule is inapplicable.
+*/
+function calculateItemRewardByRule({ rule, itemTotalCents, quantity, allowedTotalCommissionTypes }) {
 	const allowedTypes = allowedCommissionTypesSet(allowedTotalCommissionTypes);
 	if (rule.totalCommission) {
 		if (!allowedTypes.has(rule.totalCommission.type)) return null;
-		const resolvedMaxAmount = typeof rule.totalCommission.maxAmount === "number" && Number.isFinite(rule.totalCommission.maxAmount) ? rule.totalCommission.maxAmount : null;
+		const resolvedMaxAmountCents = typeof rule.totalCommission.maxAmount === "number" && Number.isFinite(rule.totalCommission.maxAmount) ? toCents(rule.totalCommission.maxAmount) : null;
 		if (rule.totalCommission.type === "fixed" && rule.totalCommission.value == null) {
-			const partnerAmtPerUnit = typeof rule.partnerSplit === "number" ? rule.partnerSplit : null;
-			const customerAmtPerUnit = typeof rule.customerSplit === "number" ? rule.customerSplit : null;
-			if (partnerAmtPerUnit == null || customerAmtPerUnit == null) return null;
-			let partner = partnerAmtPerUnit * quantity;
-			let customer = customerAmtPerUnit * quantity;
-			if (resolvedMaxAmount != null) {
-				const maxPotForLine = resolvedMaxAmount * quantity;
+			const partnerAmtPerUnitCents = typeof rule.partnerSplit === "number" ? toCents(rule.partnerSplit) : null;
+			const customerAmtPerUnitCents = typeof rule.customerSplit === "number" ? toCents(rule.customerSplit) : null;
+			if (partnerAmtPerUnitCents == null || customerAmtPerUnitCents == null) return null;
+			let partner = partnerAmtPerUnitCents * quantity;
+			let customer = customerAmtPerUnitCents * quantity;
+			if (resolvedMaxAmountCents != null) {
+				const maxPotForLine = resolvedMaxAmountCents * quantity;
 				const totalPot = partner + customer;
 				if (totalPot > maxPotForLine && totalPot > 0) {
 					const ratio = maxPotForLine / totalPot;
@@ -818,7 +835,6 @@ function calculateItemRewardByRule({ rule, itemTotal, quantity, allowedTotalComm
 				customer
 			};
 		}
-		let totalPot = 0;
 		if (rule.totalCommission.type === "percentage") {
 			const commissionValue = typeof rule.totalCommission.value === "number" && Number.isFinite(rule.totalCommission.value) ? rule.totalCommission.value : null;
 			if (commissionValue == null) {
@@ -826,58 +842,63 @@ function calculateItemRewardByRule({ rule, itemTotal, quantity, allowedTotalComm
 				if (partnerPercentInput == null || partnerPercentInput < 0 || partnerPercentInput > 100) return null;
 				const customerPercentInput = typeof rule.customerPercent === "number" ? rule.customerPercent : typeof rule.customerSplit === "number" ? rule.customerSplit : 100 - partnerPercentInput;
 				if (customerPercentInput == null || customerPercentInput < 0 || customerPercentInput > 100) return null;
-				const partner = itemTotal * partnerPercentInput / 100;
-				const customer = itemTotal * customerPercentInput / 100;
-				if (resolvedMaxAmount != null) {
-					const maxPotForLine = resolvedMaxAmount * quantity;
+				let partner = Math.floor(itemTotalCents * partnerPercentInput / 100);
+				let customer = Math.floor(itemTotalCents * customerPercentInput / 100);
+				if (resolvedMaxAmountCents != null) {
+					const maxPotForLine = resolvedMaxAmountCents * quantity;
 					const totalForLine = partner + customer;
 					if (totalForLine > maxPotForLine && totalForLine > 0) {
 						const ratio = maxPotForLine / totalForLine;
-						return {
-							partner: Math.floor(partner * ratio),
-							customer: Math.floor(customer * ratio)
-						};
+						partner = Math.floor(partner * ratio);
+						customer = Math.floor(customer * ratio);
 					}
 				}
 				return {
-					partner: Math.floor(partner),
-					customer: Math.floor(customer)
+					partner,
+					customer
 				};
 			}
-			totalPot = itemTotal * commissionValue / 100;
-		} else {
+			let totalPotCents = Math.floor(itemTotalCents * commissionValue / 100);
+			if (resolvedMaxAmountCents != null) {
+				const maxPotForLine = resolvedMaxAmountCents * quantity;
+				if (totalPotCents > maxPotForLine) totalPotCents = maxPotForLine;
+			}
 			const splits = getRuleSplits(rule);
 			if (!splits) return null;
-			totalPot = rule.totalCommission.value * quantity;
-			if (resolvedMaxAmount != null) {
-				const maxPotForLine = resolvedMaxAmount * quantity;
-				if (totalPot > maxPotForLine) totalPot = maxPotForLine;
-			}
 			return {
-				partner: Math.floor(totalPot * splits.partnerSplit / 100),
-				customer: Math.floor(totalPot * splits.customerSplit / 100)
+				partner: Math.floor(totalPotCents * splits.partnerSplit / 100),
+				customer: Math.floor(totalPotCents * splits.customerSplit / 100)
 			};
 		}
-		if (resolvedMaxAmount != null) {
-			const maxPotForLine = resolvedMaxAmount * quantity;
-			if (totalPot > maxPotForLine) totalPot = maxPotForLine;
+		{
+			const splits = getRuleSplits(rule);
+			if (!splits) return null;
+			let totalPotCents = toCents(rule.totalCommission.value) * quantity;
+			if (resolvedMaxAmountCents != null) {
+				const maxPotForLine = resolvedMaxAmountCents * quantity;
+				if (totalPotCents > maxPotForLine) totalPotCents = maxPotForLine;
+			}
+			return {
+				partner: Math.floor(totalPotCents * splits.partnerSplit / 100),
+				customer: Math.floor(totalPotCents * splits.customerSplit / 100)
+			};
 		}
-		const splits = getRuleSplits(rule);
-		if (!splits) return null;
-		return {
-			partner: Math.floor(totalPot * splits.partnerSplit / 100),
-			customer: Math.floor(totalPot * splits.customerSplit / 100)
-		};
 	}
 	if (rule.referrerReward && rule.refereeReward) {
 		let partner = 0;
-		if (rule.referrerReward.type === "percentage") partner = itemTotal * rule.referrerReward.value / 100;
-		else partner = rule.referrerReward.value * quantity;
-		if (rule.referrerReward.maxReward != null && partner > rule.referrerReward.maxReward) partner = rule.referrerReward.maxReward;
+		if (rule.referrerReward.type === "percentage") partner = Math.floor(itemTotalCents * rule.referrerReward.value / 100);
+		else partner = toCents(rule.referrerReward.value) * quantity;
+		if (rule.referrerReward.maxReward != null) {
+			const maxCents = toCents(rule.referrerReward.maxReward);
+			if (partner > maxCents) partner = maxCents;
+		}
 		let customer = 0;
-		if (rule.refereeReward.type === "percentage") customer = itemTotal * rule.refereeReward.value / 100;
-		else customer = rule.refereeReward.value * quantity;
-		if (rule.refereeReward.maxReward != null && customer > rule.refereeReward.maxReward) customer = rule.refereeReward.maxReward;
+		if (rule.refereeReward.type === "percentage") customer = Math.floor(itemTotalCents * rule.refereeReward.value / 100);
+		else customer = toCents(rule.refereeReward.value) * quantity;
+		if (rule.refereeReward.maxReward != null) {
+			const maxCents = toCents(rule.refereeReward.maxReward);
+			if (customer > maxCents) customer = maxCents;
+		}
 		return {
 			partner,
 			customer
@@ -893,12 +914,12 @@ function getItemCategoryIds(item) {
 function getItemTagIds(item) {
 	return Array.isArray(item?.product?.tags) ? normalizeIds(item.product.tags) : [];
 }
-function selectBestRuleForItem({ rules, item, itemTotal, quantity, cartTotal, minOrderAmount, allowedTotalCommissionTypes }) {
+function selectBestRuleForItem({ rules, item, itemTotalCents, quantity, cartTotalCents, minOrderAmountCents, allowedTotalCommissionTypes }) {
 	const allowedTypes = allowedCommissionTypesSet(allowedTotalCommissionTypes);
 	const eligibleRules = rules.filter((rule) => {
 		if (!(rule?.totalCommission?.type ? allowedTypes.has(rule.totalCommission.type) : true)) return false;
-		const resolvedMinOrderAmount = typeof minOrderAmount === "number" && Number.isFinite(minOrderAmount) ? minOrderAmount : typeof rule?.minOrderAmount === "number" && Number.isFinite(rule.minOrderAmount) ? rule.minOrderAmount : null;
-		if (resolvedMinOrderAmount != null) return cartTotal >= resolvedMinOrderAmount;
+		const resolvedMinCents = minOrderAmountCents != null && Number.isFinite(minOrderAmountCents) ? minOrderAmountCents : typeof rule?.minOrderAmount === "number" && Number.isFinite(rule.minOrderAmount) ? toCents(rule.minOrderAmount) : null;
+		if (resolvedMinCents != null) return cartTotalCents >= resolvedMinCents;
 		return true;
 	});
 	const productId = relationId$5(item.product);
@@ -921,7 +942,7 @@ function selectBestRuleForItem({ rules, item, itemTotal, quantity, cartTotal, mi
 	for (const rule of candidates) {
 		const reward = calculateItemRewardByRule({
 			rule,
-			itemTotal,
+			itemTotalCents,
 			quantity,
 			allowedTotalCommissionTypes
 		});
@@ -947,6 +968,10 @@ function selectBestRuleForItem({ rules, item, itemTotal, quantity, cartTotal, mi
 	}
 	return best;
 }
+/**
+* Returns the effective minimum order amount for a program in NORMAL CURRENCY.
+* Returns null if there is no minimum.
+*/
 function getProgramMinimumOrderAmount({ program, allowedTotalCommissionTypes }) {
 	if (typeof program?.minOrderAmount === "number" && Number.isFinite(program.minOrderAmount)) return program.minOrderAmount;
 	const rules = Array.isArray(program?.commissionRules) ? program.commissionRules : [];
@@ -959,50 +984,66 @@ function getProgramMinimumOrderAmount({ program, allowedTotalCommissionTypes })
 	if (!minValues.length) return null;
 	return Math.min(...minValues);
 }
+/**
+* Calculate total partner commission and customer discount for a cart.
+*
+* All monetary inputs are in NORMAL CURRENCY.
+* Returns results in NORMAL CURRENCY (2 dp).
+*/
 function calculateCommissionAndDiscount({ cartItems, program, currencyCode = "AED", cartTotal = 0, allowedTotalCommissionTypes }) {
 	const rules = Array.isArray(program?.commissionRules) ? program.commissionRules : [];
 	if (!rules.length) return {
 		partnerCommission: 0,
 		customerDiscount: 0
 	};
-	let totalPartnerCommission = 0;
-	let totalCustomerDiscount = 0;
+	const cartTotalCents = toCents(cartTotal);
+	const programMinOrderAmountCents = typeof program?.minOrderAmount === "number" && Number.isFinite(program.minOrderAmount) ? toCents(program.minOrderAmount) : null;
+	let totalPartnerCents = 0;
+	let totalCustomerCents = 0;
 	for (const item of cartItems) {
 		const product = typeof item.product === "object" ? item.product : {};
-		const itemPrice = getCartItemUnitPrice({
+		const itemPriceCurrency = getCartItemUnitPrice({
 			item,
 			product,
 			variant: typeof item.variant === "object" ? item.variant : {},
 			currencyCode
 		});
 		const quantity = item.quantity ?? 1;
-		const itemTotal = itemPrice * quantity;
+		const itemTotalCents = toCents(itemPriceCurrency) * quantity;
 		const bestMatch = selectBestRuleForItem({
 			rules,
 			item: {
 				...item,
 				product
 			},
-			itemTotal,
+			itemTotalCents,
 			quantity,
-			cartTotal,
-			minOrderAmount: typeof program?.minOrderAmount === "number" && Number.isFinite(program.minOrderAmount) ? program.minOrderAmount : null,
+			cartTotalCents,
+			minOrderAmountCents: programMinOrderAmountCents,
 			allowedTotalCommissionTypes
 		});
 		if (!bestMatch) continue;
-		totalPartnerCommission += bestMatch.reward.partner;
-		totalCustomerDiscount += bestMatch.reward.customer;
+		totalPartnerCents += bestMatch.reward.partner;
+		totalCustomerCents += bestMatch.reward.customer;
 	}
-	const maxPartnerCommissionPerOrder = typeof program?.maxPartnerCommissionPerOrder === "number" && Number.isFinite(program.maxPartnerCommissionPerOrder) ? program.maxPartnerCommissionPerOrder : null;
-	const maxCustomerDiscountPerOrder = typeof program?.maxCustomerDiscountPerOrder === "number" && Number.isFinite(program.maxCustomerDiscountPerOrder) ? program.maxCustomerDiscountPerOrder : null;
-	if (maxPartnerCommissionPerOrder != null) totalPartnerCommission = Math.min(totalPartnerCommission, maxPartnerCommissionPerOrder);
-	if (maxCustomerDiscountPerOrder != null) totalCustomerDiscount = Math.min(totalCustomerDiscount, maxCustomerDiscountPerOrder);
+	const maxPartnerCents = typeof program?.maxPartnerCommissionPerOrder === "number" && Number.isFinite(program.maxPartnerCommissionPerOrder) ? toCents(program.maxPartnerCommissionPerOrder) : null;
+	const maxCustomerCents = typeof program?.maxCustomerDiscountPerOrder === "number" && Number.isFinite(program.maxCustomerDiscountPerOrder) ? toCents(program.maxCustomerDiscountPerOrder) : null;
+	if (maxPartnerCents != null) totalPartnerCents = Math.min(totalPartnerCents, maxPartnerCents);
+	if (maxCustomerCents != null) totalCustomerCents = Math.min(totalCustomerCents, maxCustomerCents);
 	return {
-		partnerCommission: totalPartnerCommission,
-		customerDiscount: totalCustomerDiscount
+		partnerCommission: fromCents(totalPartnerCents),
+		customerDiscount: fromCents(totalCustomerCents)
 	};
 }
 //#endregion
+//#region src/utilities/roundTo2.ts
+/**
+* Rounds a number to 2 decimal places (standard for monetary values).
+*/
+function roundTo2(value) {
+	return Math.round(value * 100) / 100;
+}
+//#endregion
 //#region src/endpoints/applyCoupon.ts
 function relationId$4(value) {
 	if (value == null) return null;