@wtree/payload-ecommerce-coupon 3.78.8 → 3.78.10

package/dist/index.mjs

@@ -459,102 +459,88 @@ const createReferralProgramsCollection = (pluginConfig) => {
 			update: access.isAdmin || (() => false),
 			delete: access.isAdmin || (() => false)
 		},
-		hooks: {
-			beforeChange: [({ data }) => {
-				if (!data.commissionRules || !Array.isArray(data.commissionRules) || data.commissionRules.length === 0) throw new APIError("At least one commission rule is required", 400);
-				const rawMaxPartner = toNumber(data.maxPartnerCommissionPerOrder);
-				if (rawMaxPartner != null && rawMaxPartner < 0) throw new APIError("Maximum commission per order for partner must be a non-negative number", 400);
-				const rawMaxCustomer = toNumber(data.maxCustomerDiscountPerOrder);
-				if (rawMaxCustomer != null && rawMaxCustomer < 0) throw new APIError("Maximum discount for customer per order must be a non-negative number", 400);
-				const rawMinOrder = toNumber(data.minOrderAmount);
-				if (rawMinOrder != null && rawMinOrder < 0) throw new APIError("Minimum Order Amount must be a non-negative number", 400);
-				data.maxPartnerCommissionPerOrder = rawMaxPartner != null ? Math.round(rawMaxPartner * 100) : null;
-				data.maxCustomerDiscountPerOrder = rawMaxCustomer != null ? Math.round(rawMaxCustomer * 100) : null;
-				data.minOrderAmount = rawMinOrder != null ? Math.round(rawMinOrder * 100) : null;
-				data.commissionRules = data.commissionRules.map((rule, index) => {
-					const r = rule;
-					if (!r.totalCommission) throw new APIError(`Commission rule ${index + 1}: Total Commission is required`, 400);
-					if (!r.totalCommission.type || !allowedTotalCommissionTypes.includes(r.totalCommission.type)) throw new APIError(`Commission rule ${index + 1}: Total Commission type must be one of ${allowedTotalCommissionTypes.join(", ")}`, 400);
-					const type = r.totalCommission.type;
-					const appliesTo = r.appliesTo ?? "all";
-					if (appliesTo === "products" && (!r.products || r.products.length === 0)) throw new APIError(`Commission rule ${index + 1}: At least one product is required`, 400);
-					if ((appliesTo === "segments" || appliesTo === "categories") && (!r.categories || r.categories.length === 0) && (!r.tags || r.tags.length === 0)) throw new APIError(`Commission rule ${index + 1}: At least one category or tag is required`, 400);
-					let partnerSplit;
-					let customerSplit;
-					let partnerPercent = null;
-					let customerPercent = null;
-					let partnerAmount = null;
-					let customerAmount = null;
-					let splitWarning = null;
-					if (type === "percentage") {
-						const partnerPctInput = toNumber(r.partnerPercent) ?? toNumber(r.partnerSplit);
-						const customerPctInput = toNumber(r.customerPercent) ?? toNumber(r.customerSplit);
-						if (partnerPctInput == null || partnerPctInput < 0 || partnerPctInput > 100) throw new APIError(`Commission rule ${index + 1}: Partner Split must be between 0 and 100`, 400);
-						if (customerPctInput != null && (customerPctInput < 0 || customerPctInput > 100)) throw new APIError(`Commission rule ${index + 1}: Customer percentage must be between 0 and 100`, 400);
-						const customerPctComputed = customerPctInput != null ? customerPctInput : 100 - partnerPctInput;
-						const percentTotal = partnerPctInput + customerPctComputed;
-						if (percentTotal > 100) throw new APIError(`Commission rule ${index + 1}: Partner percentage + Customer percentage cannot exceed 100`, 400);
-						if (percentTotal > 50) splitWarning = `High total split configured: ${percentTotal}% (partner + customer).`;
-						partnerPercent = partnerPctInput;
-						customerPercent = customerPctComputed;
-						partnerSplit = partnerPctInput;
-						customerSplit = customerPctComputed;
-					} else {
-						const partnerAmountInput = toNumber(r.partnerAmount);
-						const customerAmountInput = toNumber(r.customerAmount);
-						const legacyPartnerSplitInput = toNumber(r.partnerSplit);
-						const legacyCustomerSplitInput = toNumber(r.customerSplit);
-						const hasNewFixedInputs = partnerAmountInput != null || customerAmountInput != null;
-						const hasLegacyFixedInputs = legacyPartnerSplitInput != null || legacyCustomerSplitInput != null;
-						if (hasNewFixedInputs) {
-							if (partnerAmountInput == null || partnerAmountInput < 0) throw new APIError(`Commission rule ${index + 1}: Partner fixed amount must be a non-negative number`, 400);
-							if (customerAmountInput == null || customerAmountInput < 0) throw new APIError(`Commission rule ${index + 1}: Customer fixed amount must be a non-negative number`, 400);
-							partnerAmount = partnerAmountInput;
-							customerAmount = customerAmountInput;
-							partnerSplit = partnerAmountInput;
-							customerSplit = customerAmountInput;
-						} else if (hasLegacyFixedInputs) {
-							if (legacyPartnerSplitInput == null || legacyPartnerSplitInput < 0) throw new APIError(`Commission rule ${index + 1}: For fixed commissions, both partner and customer values must be non-negative numbers`, 400);
-							const resolvedLegacyCustomerSplit = legacyCustomerSplitInput ?? 100 - legacyPartnerSplitInput;
-							if (resolvedLegacyCustomerSplit == null || resolvedLegacyCustomerSplit < 0) throw new APIError(`Commission rule ${index + 1}: For fixed commissions, both partner and customer values must be non-negative numbers`, 400);
-							partnerSplit = legacyPartnerSplitInput;
-							customerSplit = resolvedLegacyCustomerSplit;
-							partnerAmount = null;
-							customerAmount = null;
-						} else throw new APIError(`Commission rule ${index + 1}: For fixed commissions, both partner and customer values must be provided`, 400);
-					}
-					return {
-						...rule,
-						appliesTo: appliesTo === "categories" ? "segments" : appliesTo,
-						totalCommission: {
-							type,
-							...typeof r.totalCommission.value === "number" ? { value: r.totalCommission.value } : {},
-							...typeof r.totalCommission.maxAmount === "number" ? { maxAmount: r.totalCommission.maxAmount } : {}
-						},
-						partnerPercent,
-						customerPercent,
-						partnerAmount,
-						customerAmount,
-						partnerSplit,
-						customerSplit,
-						splitWarning
-					};
-				});
-				return data;
-			}],
-			afterRead: [({ doc }) => {
-				if (!doc) return doc;
-				const unscale = (value) => {
-					const n = toNumber(value);
-					if (n == null) return null;
-					return Math.round(n / 100 * 100) / 100;
+		hooks: { beforeChange: [({ data }) => {
+			if (!data.commissionRules || !Array.isArray(data.commissionRules) || data.commissionRules.length === 0) throw new APIError("At least one commission rule is required", 400);
+			const rawMaxPartner = toNumber(data.maxPartnerCommissionPerOrder);
+			if (rawMaxPartner != null && rawMaxPartner < 0) throw new APIError("Maximum commission per order for partner must be a non-negative number", 400);
+			const rawMaxCustomer = toNumber(data.maxCustomerDiscountPerOrder);
+			if (rawMaxCustomer != null && rawMaxCustomer < 0) throw new APIError("Maximum discount for customer per order must be a non-negative number", 400);
+			const rawMinOrder = toNumber(data.minOrderAmount);
+			if (rawMinOrder != null && rawMinOrder < 0) throw new APIError("Minimum Order Amount must be a non-negative number", 400);
+			data.maxPartnerCommissionPerOrder = rawMaxPartner ?? null;
+			data.maxCustomerDiscountPerOrder = rawMaxCustomer ?? null;
+			data.minOrderAmount = rawMinOrder ?? null;
+			data.commissionRules = data.commissionRules.map((rule, index) => {
+				const r = rule;
+				if (!r.totalCommission) throw new APIError(`Commission rule ${index + 1}: Total Commission is required`, 400);
+				if (!r.totalCommission.type || !allowedTotalCommissionTypes.includes(r.totalCommission.type)) throw new APIError(`Commission rule ${index + 1}: Total Commission type must be one of ${allowedTotalCommissionTypes.join(", ")}`, 400);
+				const type = r.totalCommission.type;
+				const appliesTo = r.appliesTo ?? "all";
+				if (appliesTo === "products" && (!r.products || r.products.length === 0)) throw new APIError(`Commission rule ${index + 1}: At least one product is required`, 400);
+				if ((appliesTo === "segments" || appliesTo === "categories") && (!r.categories || r.categories.length === 0) && (!r.tags || r.tags.length === 0)) throw new APIError(`Commission rule ${index + 1}: At least one category or tag is required`, 400);
+				let partnerSplit;
+				let customerSplit;
+				let partnerPercent = null;
+				let customerPercent = null;
+				let partnerAmount = null;
+				let customerAmount = null;
+				let splitWarning = null;
+				if (type === "percentage") {
+					const partnerPctInput = toNumber(r.partnerPercent) ?? toNumber(r.partnerSplit);
+					const customerPctInput = toNumber(r.customerPercent) ?? toNumber(r.customerSplit);
+					if (partnerPctInput == null || partnerPctInput < 0 || partnerPctInput > 100) throw new APIError(`Commission rule ${index + 1}: Partner Split must be between 0 and 100`, 400);
+					if (customerPctInput != null && (customerPctInput < 0 || customerPctInput > 100)) throw new APIError(`Commission rule ${index + 1}: Customer percentage must be between 0 and 100`, 400);
+					const customerPctComputed = customerPctInput != null ? customerPctInput : 100 - partnerPctInput;
+					const percentTotal = partnerPctInput + customerPctComputed;
+					if (percentTotal > 100) throw new APIError(`Commission rule ${index + 1}: Partner percentage + Customer percentage cannot exceed 100`, 400);
+					if (percentTotal > 50) splitWarning = `High total split configured: ${percentTotal}% (partner + customer).`;
+					partnerPercent = partnerPctInput;
+					customerPercent = customerPctComputed;
+					partnerSplit = partnerPctInput;
+					customerSplit = customerPctComputed;
+				} else {
+					const partnerAmountInput = toNumber(r.partnerAmount);
+					const customerAmountInput = toNumber(r.customerAmount);
+					const legacyPartnerSplitInput = toNumber(r.partnerSplit);
+					const legacyCustomerSplitInput = toNumber(r.customerSplit);
+					const hasNewFixedInputs = partnerAmountInput != null || customerAmountInput != null;
+					const hasLegacyFixedInputs = legacyPartnerSplitInput != null || legacyCustomerSplitInput != null;
+					if (hasNewFixedInputs) {
+						if (partnerAmountInput == null || partnerAmountInput < 0) throw new APIError(`Commission rule ${index + 1}: Partner fixed amount must be a non-negative number`, 400);
+						if (customerAmountInput == null || customerAmountInput < 0) throw new APIError(`Commission rule ${index + 1}: Customer fixed amount must be a non-negative number`, 400);
+						partnerAmount = partnerAmountInput;
+						customerAmount = customerAmountInput;
+						partnerSplit = partnerAmountInput;
+						customerSplit = customerAmountInput;
+					} else if (hasLegacyFixedInputs) {
+						if (legacyPartnerSplitInput == null || legacyPartnerSplitInput < 0) throw new APIError(`Commission rule ${index + 1}: For fixed commissions, both partner and customer values must be non-negative numbers`, 400);
+						const resolvedLegacyCustomerSplit = legacyCustomerSplitInput ?? 100 - legacyPartnerSplitInput;
+						if (resolvedLegacyCustomerSplit == null || resolvedLegacyCustomerSplit < 0) throw new APIError(`Commission rule ${index + 1}: For fixed commissions, both partner and customer values must be non-negative numbers`, 400);
+						partnerSplit = legacyPartnerSplitInput;
+						customerSplit = resolvedLegacyCustomerSplit;
+						partnerAmount = null;
+						customerAmount = null;
+					} else throw new APIError(`Commission rule ${index + 1}: For fixed commissions, both partner and customer values must be provided`, 400);
+				}
+				return {
+					...rule,
+					appliesTo: appliesTo === "categories" ? "segments" : appliesTo,
+					totalCommission: {
+						type,
+						...typeof r.totalCommission.value === "number" ? { value: r.totalCommission.value } : {},
+						...typeof r.totalCommission.maxAmount === "number" ? { maxAmount: r.totalCommission.maxAmount } : {}
+					},
+					partnerPercent,
+					customerPercent,
+					partnerAmount,
+					customerAmount,
+					partnerSplit,
+					customerSplit,
+					splitWarning
 				};
-				doc.maxPartnerCommissionPerOrder = unscale(doc.maxPartnerCommissionPerOrder);
-				doc.maxCustomerDiscountPerOrder = unscale(doc.maxCustomerDiscountPerOrder);
-				doc.minOrderAmount = unscale(doc.minOrderAmount);
-				return doc;
-			}]
-		},
+			});
+			return data;
+		}] },
 		fields: [
 			{
 				name: "name",
@@ -720,14 +706,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 +741,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 +790,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 +821,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 +828,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 +900,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 +928,7 @@ function selectBestRuleForItem({ rules, item, itemTotal, quantity, cartTotal, mi
 	for (const rule of candidates) {
 		const reward = calculateItemRewardByRule({
 			rule,
-			itemTotal,
+			itemTotalCents,
 			quantity,
 			allowedTotalCommissionTypes
 		});
@@ -947,6 +954,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 +970,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;