@classytic/primitives 0.28.0 → 0.30.0

package/dist/split-allocation.mjs

@@ -88,6 +88,7 @@ function resolveWeights(subjects, method) {
 function distribute(total, weights) {
 	const weightSum = weights.reduce((a, b) => a + b, 0);
 	if (weightSum === 0) return weights.map(() => 0);
+	if (weights.every(Number.isSafeInteger) && Number.isSafeInteger(weightSum)) return distributeExact(total, weights, weightSum);
 	const raw = weights.map((w) => total * w / weightSum);
 	const floored = raw.map((r) => Math.floor(r));
 	const residue = total - floored.reduce((a, b) => a + b, 0);
@@ -107,9 +108,64 @@ function distribute(total, weights) {
 	}
 	return result;
 }
+/**
+* Largest remainder in exact integer arithmetic, for integer weights (minor-unit amounts). Shares
+* and remainders are compared as BigInt quotients of one denominator, so neither the floor nor the
+* remainder ranking can drift once `total × weight` passes 2^53.
+*/
+function distributeExact(total, weights, weightSum) {
+	const t = BigInt(total);
+	const d = BigInt(weightSum);
+	const shares = weights.map((w) => {
+		const n = t * BigInt(w);
+		return {
+			floor: n / d,
+			rem: n % d
+		};
+	});
+	const result = shares.map((s) => Number(s.floor));
+	const residue = total - result.reduce((a, b) => a + b, 0);
+	const order = shares.map((s, i) => ({
+		i,
+		rem: s.rem
+	})).sort((a, b) => a.rem === b.rem ? a.i - b.i : a.rem > b.rem ? -1 : 1);
+	for (let k = 0; k < residue; k++) {
+		const entry = order[k];
+		if (entry === void 0) throw new Error("split-allocation invariant: residue exceeds the subject count");
+		result[entry.i] = (result[entry.i] ?? 0) + 1;
+	}
+	return result;
+}
 /** True if `sum(parts[i].amount) === result.total`. Useful as an assertion in host code. */
 function isBalanced(result) {
 	return result.parts.reduce((acc, p) => acc + p.amount, 0) === result.total;
 }
+/**
+* THE discount allocation: spread a document-level discount over its eligible lines, by value,
+* exact largest remainder. Every document that splits one discount — the order, its invoice,
+* its credit notes, a return's value — calls this, so they agree to the minor unit.
+*
+* Returns a FULL map in input order: every subject id, `0` for an ineligible or zero-weight one.
+* `0` discount allocates zeros; a discount equal to the eligible base allocates all of it; a
+* discount above it throws `DISCOUNT_EXCEEDS_BASE` — the figures disagree.
+*/
+function allocateDiscount(discount, subjects) {
+	if (!Number.isInteger(discount) || discount < 0) throw new SplitAllocationError("INVALID_TOTAL", `discount must be a non-negative integer, got ${discount}`);
+	const out = /* @__PURE__ */ new Map();
+	for (const s of subjects) {
+		if (out.has(s.id)) throw new SplitAllocationError("DUPLICATE_SUBJECT_ID", `duplicate subject id: ${s.id}`);
+		if (!Number.isFinite(s.weight) || s.weight < 0) throw new SplitAllocationError("INVALID_WEIGHT", `subject ${s.id}: weight must be a non-negative number`);
+		out.set(s.id, 0);
+	}
+	const eligible = subjects.filter((s) => s.discountable !== false && s.weight > 0);
+	const base = eligible.reduce((sum, s) => sum + s.weight, 0);
+	if (discount > base) throw new SplitAllocationError("DISCOUNT_EXCEEDS_BASE", `discount ${discount} exceeds the discountable base ${base}`);
+	if (discount === 0) return out;
+	for (const part of allocate(discount, eligible.map((s) => ({
+		id: s.id,
+		weight: s.weight
+	})), "by-value").parts) out.set(part.id, part.amount);
+	return out;
+}
 //#endregion
-export { SplitAllocationError, allocate, isBalanced };
+export { SplitAllocationError, allocate, allocateDiscount, isBalanced };