@amboras-dev/money 0.0.0-stage → 0.2.0

package/dist/commerce.js

@@ -0,0 +1,516 @@
+import { $ as describeValue, B as decimalOf, E as resolveCurrency, Q as MoneyError, X as mulDiv, Z as ratioToDecimal, dt as roundToScale, et as addDecimal, i as medusaAmountDecimal, pt as toDecimalText, rt as divRound, s as storedDecimal, st as multiplyDecimal, t as boundedMoney, ut as pow10 } from "./money-WhnGiI00.js";
+import { a as unitSize, r as roundStoredDecimal, t as mulDivToUnit } from "./rounding-g9rvye0k.js";
+import { n as allocateUnits, t as allocate } from "./allocate-X7_jAtOj.js";
+import { i as percentRatio, n as hundredPercent, t as basisPointsOf } from "./percent-D1VB9xXG.js";
+import { t as formatMoney } from "./format-BdPnijvn.js";
+import { a as readStoredDecimal, c as storedFieldValue } from "./medusa-DqJY1qpj.js";
+import { n as retailUnits } from "./retail-1mu888J1.js";
+//#region src/commerce/convention.ts
+/**
+* Currencies with storage digits: step 1, `'x100'`. Zero-decimal currencies: step 100 when
+* there is a positive sample and every positive sample is a multiple of 100 (the platform
+* convention), else step 1 `'whole-unit'` (never truncate a whole-unit store to hundreds).
+*/
+function storageConventionOf(currency, samples) {
+	const info = resolveCurrency(currency, { allowHistoric: true });
+	for (const s of samples) storedDecimal(s);
+	if (info.storageDigits !== 0) return {
+		step: 1,
+		convention: "x100"
+	};
+	const step = unitSize(info, "currency");
+	const positive = samples.filter((s) => s.amount > 0);
+	return positive.length > 0 && positive.every((s) => BigInt(s.amount) % step === 0n) ? {
+		step: 100,
+		convention: "x100"
+	} : {
+		step: 1,
+		convention: "whole-unit"
+	};
+}
+//#endregion
+//#region src/commerce/shared.ts
+/** The one currency of `amounts` (the first defined one decides) and their stored integers. Throws `currency_mismatch`. */
+function oneCurrency(amounts, verb) {
+	let info;
+	const units = amounts.map((m) => {
+		const own = storedDecimal(m).info;
+		if (info && own.code !== info.code) throw new MoneyError("currency_mismatch", `Cannot ${verb} ${info.code} and ${own.code}`);
+		info = info ?? own;
+		return BigInt(m.amount);
+	});
+	return {
+		info,
+		units
+	};
+}
+/** A percent (or any plain decimal) as an exact Decimal; `parse` / `amount_invalid` as `decimalOf`. */
+function percentValue(value, field) {
+	return decimalOf(value, true, field);
+}
+/** `value` clamped to [0, 100] percent. */
+function clampPercent(value) {
+	if (value.units < 0n) return {
+		units: 0n,
+		scale: 0
+	};
+	return value.units > hundredPercent(value.scale) ? {
+		units: 100n,
+		scale: 0
+	} : value;
+}
+/** A positive safe integer, else `amount_invalid`. */
+function positiveInteger(value, name) {
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1) throw new MoneyError("amount_invalid", `${name} must be a positive integer, got ${describeValue(value)}`);
+	return BigInt(value);
+}
+/** A non-negative safe integer, else `amount_invalid`. */
+function nonNegativeInteger(value, name) {
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) throw new MoneyError("amount_invalid", `${name} must be a non-negative integer, got ${describeValue(value)}`);
+	return BigInt(value);
+}
+/** `decimals` as a digit count from 0 to 20, else `amount_invalid`. */
+function digitsOf(decimals, name = "decimals") {
+	if (typeof decimals !== "number" || !Number.isSafeInteger(decimals) || decimals < 0 || decimals > 20) throw new MoneyError("amount_invalid", `${name} must be an integer from 0 to 20, got ${describeValue(decimals)}`);
+	return decimals;
+}
+//#endregion
+//#region src/commerce/cost.ts
+const scaleOf = (scale) => digitsOf(scale ?? 4, "scale");
+function quantityOf(value, name) {
+	if (typeof value !== "number" || !Number.isSafeInteger(value)) throw new MoneyError("amount_invalid", `${name} must be an integer, got ${describeValue(value)}`);
+	return BigInt(value);
+}
+/**
+* Extra costs (freight, duties) spread over receipt lines by quantity, exactly: `extras`
+* (rounded half-up to `scale`, default 4) is allocated with the last line absorbing the
+* remainder; each line's landed unit cost is `max(0, round(unitCost + share / quantity))` at
+* `scale`. Non-positive extras or quantities spread nothing.
+*/
+function landedUnitCosts(lines, extras, options = {}) {
+	const scale = scaleOf(options.scale);
+	const quantities = lines.map((l, i) => quantityOf(l.quantity, `lines[${i}].quantity`));
+	const pot = roundToScale(decimalOf(extras, true, "extras"), scale, "half-up");
+	const shares = pot.units > 0n && quantities.every((q) => q >= 0n) && quantities.some((q) => q > 0n) ? allocate(toDecimalText(pot), quantities.map((q) => Number(q)), {
+		strategy: "last",
+		scale
+	}) : lines.map(() => "0");
+	return lines.map((line, i) => {
+		const unit = decimalOf(line.unitCost, true, `lines[${i}].unitCost`);
+		const share = roundToScale(decimalOf(shares[i]), scale, "down").units;
+		const q = quantities[i];
+		const total = addDecimal(multiplyDecimal(unit, {
+			units: q,
+			scale: 0
+		}), {
+			units: share,
+			scale
+		});
+		const landed = q > 0n ? ratioToDecimal(total.units, pow10(total.scale) * q, scale) : roundToScale(unit, scale, "half-up");
+		return {
+			share: shares[i],
+			landedUnitCost: toDecimalText({
+				units: landed.units > 0n ? landed.units : 0n,
+				scale
+			})
+		};
+	});
+}
+/**
+* The weighted-average unit cost after a receipt: the receipt's cost (half-up to `scale`,
+* default 4) when there is no average, nothing on hand or nothing received; else
+* `(onHand x average + quantity x unitCost) / (onHand + quantity)` half-up to `scale`.
+*/
+function weightedAverageCost(current, receipt, options = {}) {
+	const scale = scaleOf(options.scale);
+	const onHand = quantityOf(current.onHand, "onHand");
+	const quantity = quantityOf(receipt.quantity, "quantity");
+	const cost = decimalOf(receipt.unitCost, true, "unitCost");
+	if (current.average === null || onHand <= 0n || quantity <= 0n) return toDecimalText(roundToScale(cost, scale, "half-up"));
+	const average = decimalOf(current.average, true, "average");
+	const held = multiplyDecimal({
+		units: onHand,
+		scale: 0
+	}, average);
+	const sum = addDecimal(held, multiplyDecimal({
+		units: quantity,
+		scale: 0
+	}, cost));
+	return toDecimalText(ratioToDecimal(sum.units, pow10(sum.scale) * (onHand + quantity), scale));
+}
+//#endregion
+//#region src/commerce/discount.ts
+const isMoney = (value) => typeof value === "object" && value !== null;
+/**
+* The discount `spec` takes off `base` (a line or order total), clamped to `[0, base]`; a
+* non-positive base gives 0. A percentage of the total rounds once (`per: 'total'`) or per
+* unit then times the quantity (`per: 'unit'`: 10% of 2 x 18.99 truncated is 2 x 1.89); a
+* fixed amount is Money in base's currency, per unit times the quantity with `per: 'unit'`.
+*/
+function discountAmount(spec, base, options = {}) {
+	const { info } = storedDecimal(base);
+	const total = BigInt(base.amount);
+	const quantity = options.per === "unit" ? positiveInteger(options.quantity, "quantity") : 1n;
+	let amount;
+	if (spec?.type === "percentage") {
+		if (isMoney(spec.value)) throw new MoneyError("amount_invalid", "A percentage discount takes a percent, not Money");
+		const pct = clampPercent(percentValue(spec.value, "value"));
+		const denominator = hundredPercent(pct.scale) * quantity;
+		amount = mulDivToUnit(total, pct.units, denominator, info, options.unit ?? "currency", options.rounding) * quantity;
+	} else if (spec?.type === "fixed") {
+		if (!isMoney(spec.value)) throw new MoneyError("amount_invalid", `A fixed discount takes Money, got ${describeValue(spec.value)}`);
+		amount = oneCurrency([base, spec.value], "discount").units[1] * quantity;
+	} else throw new MoneyError("amount_invalid", `Unknown discount type: ${describeValue(spec?.type)}`);
+	if (total <= 0n || amount <= 0n) return boundedMoney(0n, info);
+	return boundedMoney(amount < total ? amount : total, info);
+}
+/**
+* The reward of a buy X get Y offer on one line: `min(quantity, maxQuantity)` discounted
+* units, each `percent` of the unit price (rounded once on the total to the currency unit) or
+* a fixed amount off each, never more than the unit price (promotion `fixBuyGetFixedRewards`).
+* The units come from the input, never recovered from an amount.
+*/
+function buyGetReward(input) {
+	const { info } = storedDecimal(input.unitPrice);
+	const price = BigInt(input.unitPrice.amount);
+	const quantity = nonNegativeInteger(input.quantity, "quantity");
+	const cap = input.maxQuantity === void 0 ? quantity : nonNegativeInteger(input.maxQuantity, "maxQuantity");
+	const units = quantity < cap ? quantity : cap;
+	let amount;
+	if (input.reward?.kind === "percent") {
+		const pct = clampPercent(percentValue(input.reward.value, "reward.value"));
+		amount = mulDivToUnit(price * units, pct.units, hundredPercent(pct.scale), info, "currency");
+	} else if (input.reward?.kind === "fixed-each") {
+		const off = oneCurrency([input.unitPrice, input.reward.value], "reward").units[1];
+		amount = (off < price ? off : price) * units;
+	} else throw new MoneyError("amount_invalid", `Unknown reward kind: ${describeValue(input.reward?.kind)}`);
+	return {
+		amount: boundedMoney(amount > 0n ? amount : 0n, info),
+		discountedUnits: Number(units)
+	};
+}
+/** `'10%'`, `'12.5%'` (up to 2 decimals, half-up) or the fixed amount via `formatMoney` (its currency must be `currency`). */
+function formatDiscount(spec, currency, options = {}) {
+	const info = resolveCurrency(currency, { allowHistoric: true });
+	if (spec?.type === "percentage" && !isMoney(spec.value)) {
+		const pct = percentValue(spec.value, "value");
+		return `${toDecimalText(roundToScale(pct, 2, "half-up"))}%`;
+	}
+	if (spec?.type === "fixed" && isMoney(spec.value)) {
+		const own = storedDecimal(spec.value).info;
+		if (own.code !== info.code) throw new MoneyError("currency_mismatch", `Discount in ${own.code}, shown in ${info.code}`);
+		return formatMoney(spec.value, { locale: options.locale });
+	}
+	throw new MoneyError("amount_invalid", `Not a discount: ${describeValue(spec)}`);
+}
+//#endregion
+//#region src/commerce/order-value.ts
+const negate = (a) => ({
+	units: -a.units,
+	scale: a.scale
+});
+const ZERO = {
+	units: 0n,
+	scale: 0
+};
+/** Sum of lines `max(0, unit_price x quantity - sum(adjustments))`; null when any part is unreadable. */
+function itemsValue(items) {
+	let total = ZERO;
+	for (const item of items) {
+		const price = medusaAmountDecimal(item?.unit_price);
+		const quantity = medusaAmountDecimal(item?.quantity);
+		if (!price || !quantity) return null;
+		let line = multiplyDecimal(price, quantity);
+		for (const adjustment of item.adjustments ?? []) {
+			const amount = medusaAmountDecimal(adjustment?.amount);
+			if (!amount) return null;
+			line = addDecimal(line, negate(amount));
+		}
+		if (line.units > 0n) total = addDecimal(total, line);
+	}
+	return total;
+}
+/** An optional total: absent (null/undefined) is 0, unreadable is null. */
+const optional = (raw) => raw === null || raw === void 0 ? ZERO : medusaAmountDecimal(raw);
+/**
+* The value an order reports to ad platforms, and where it came from: the graph total when
+* trusted and positive, else the summary total (a genuine 0 or a negative is kept), else the
+* items netted of adjustments when positive, else null. The result is rounded half-up to a
+* storage unit. Skipping a send when the value is not positive (GA4) stays an app policy.
+*/
+function resolveOrderValue(input) {
+	const info = resolveCurrency(input.currency, { allowHistoric: true });
+	const toMoney = (d) => roundStoredDecimal(d, info);
+	const net = (total) => {
+		if (input.basis !== "net-of-tax-shipping") return total;
+		const tax = optional(input.taxTotal);
+		const shipping = optional(input.shippingTotal);
+		return tax && shipping ? addDecimal(total, negate(addDecimal(tax, shipping))) : null;
+	};
+	const graph = input.trustGraph ? medusaAmountDecimal(input.graphTotal) : null;
+	if (graph && graph.units > 0n) {
+		const value = net(graph);
+		return value ? {
+			value: toMoney(value),
+			source: "graph"
+		} : null;
+	}
+	const summary = medusaAmountDecimal(input.summaryTotal);
+	if (summary) {
+		const value = net(summary);
+		return value ? {
+			value: toMoney(value),
+			source: "summary"
+		} : null;
+	}
+	const items = input.items ? itemsValue(input.items) : null;
+	return items && items.units > 0n ? {
+		value: toMoney(items),
+		source: "items"
+	} : null;
+}
+//#endregion
+//#region src/commerce/payable.ts
+/**
+* `false` when the cart can complete with no payment (`total <= 0` and no negative credit-line
+* balance: `credit_line_total >= 0 && total <= 0`), `true` when it must be paid, `undefined`
+* when the total is not a finite number (still loading: fail closed, never "free"). As in the
+* starter, only a number counts as a total, and an absent credit-line total counts as none.
+*/
+function requiresPayment(input, currency) {
+	resolveCurrency(currency, { allowHistoric: true });
+	const total = input?.total;
+	if (typeof total !== "number" || !Number.isFinite(total)) return void 0;
+	const credit = input.creditLineTotal;
+	return !(total <= 0 && (credit == null || credit >= 0));
+}
+//#endregion
+//#region src/commerce/pricing.ts
+/**
+* `m` with a markup: exact percent and flat in `order`, one rounding to a storage unit, then
+* clamped to `[floor, ceiling]`, then to `>= 0`. A non-positive `m` (a failed quote) is
+* returned unchanged.
+*/
+function applyMarkup(m, options) {
+	const { info } = oneCurrency([m, ...[
+		options.flat,
+		options.floor,
+		options.ceiling
+	].filter((x) => x !== void 0)], "mark up");
+	const amount = BigInt(m.amount);
+	if (amount <= 0n) return m;
+	const pct = percentValue(options.percent ?? 0, "percent");
+	const scale = hundredPercent(pct.scale);
+	const factor = scale + pct.units;
+	const flat = options.flat ? BigInt(options.flat.amount) : 0n;
+	const rounding = options.rounding ?? "half-up";
+	let value = options.order === "flat-then-percent" ? mulDiv(amount + flat, factor, scale, rounding) : divRound(amount * factor + flat * scale, scale, rounding);
+	if (options.floor && value < BigInt(options.floor.amount)) value = BigInt(options.floor.amount);
+	if (options.ceiling && value > BigInt(options.ceiling.amount)) value = BigInt(options.ceiling.amount);
+	return boundedMoney(value > 0n ? value : 0n, info);
+}
+/**
+* The one retail price:
+* - AliExpress (`markup: { percent }`): `cost x (1 + percent / 100)`, exact, then `rounding`
+*   once (`'none'`: half-up to the currency unit; `'.99'`, `'.95'`, `'whole'`: up to the ending).
+* - Domains (`markup: { bps, capTiers }`, integer cents): `markup = min(round(cost x bps / 1e4),
+*   cap)` with the cap of the first tier whose `below` the cost is under (or that has none);
+*   `subtotal = cost + markup + extras`; `fee = ceil(subtotal x feeBps / 1e4) + fixed`; then
+*   `max(roundRetail(subtotal + fee, rounding), floor)` (`'up-to-99'` for domains).
+*/
+function retailPrice(input) {
+	const tiers = "bps" in input.markup ? input.markup.capTiers ?? [] : [];
+	const optional = [
+		input.extras,
+		input.fee?.fixed,
+		input.floor,
+		...tiers.flatMap((t) => [t.cap, t.below])
+	];
+	const { info } = oneCurrency([input.cost, ...optional.filter((x) => x !== void 0)], "price");
+	const cost = BigInt(input.cost.amount);
+	let p;
+	let q;
+	if ("percent" in input.markup) {
+		const pct = percentValue(input.markup.percent, "markup.percent");
+		q = hundredPercent(pct.scale);
+		p = cost * (q + pct.units);
+	} else if ("bps" in input.markup) {
+		const bps = nonNegativeInteger(input.markup.bps, "markup.bps");
+		let markup = basisPointsOf(cost, bps, "half-up");
+		const tier = tiers.find((t) => t.below === void 0 || cost < BigInt(t.below.amount));
+		if (tier && markup > BigInt(tier.cap.amount)) markup = BigInt(tier.cap.amount);
+		p = cost + markup;
+		q = 1n;
+	} else throw new MoneyError("amount_invalid", `markup needs percent or bps, got ${describeValue(input.markup)}`);
+	if (input.extras) p += BigInt(input.extras.amount) * q;
+	if (input.fee) {
+		const feeBps = nonNegativeInteger(input.fee.bps, "fee.bps");
+		const fee = basisPointsOf(p, feeBps, "ceil", q) + BigInt(input.fee.fixed.amount);
+		p += fee * q;
+	}
+	let price = retailUnits(p, q, info, input.rounding ?? "none");
+	if (input.floor && price < BigInt(input.floor.amount)) price = BigInt(input.floor.amount);
+	return boundedMoney(price, info);
+}
+/** `(price - cost) / price` in percent, half-up to `decimals` (default 1); a non-positive price gives 0. */
+function marginPercent(price, cost, options = {}) {
+	const [p, c] = oneCurrency([price, cost], "compare").units;
+	const decimals = digitsOf(options.decimals ?? 1);
+	if (p <= 0n) return 0;
+	return Number(toDecimalText(percentRatio(p - c, p, decimals)));
+}
+/**
+* The change from `from` to `to` in percent, half-up to `decimals` (default 1): `'change'`
+* (default) is `(to - from) / from`, `'off'` the discount `(from - to) / from` (promotion
+* percent off, subscription `discount_percentage`). A non-positive `from` gives null.
+*/
+function percentChange(from, to, options = {}) {
+	const [f, t] = oneCurrency([from, to], "compare").units;
+	const decimals = digitsOf(options.decimals ?? 1);
+	if (f <= 0n) return null;
+	const delta = options.as === "off" ? f - t : t - f;
+	return Number(toDecimalText(percentRatio(delta, f, decimals)));
+}
+/** What is kept of a charge after a card fee: `m - round(m x bps / 1e4) - fixed`. */
+function netOfFee(m, fee) {
+	const { info, units } = oneCurrency([m, fee.fixed], "net");
+	const bps = nonNegativeInteger(fee.bps, "fee.bps");
+	const [amount, fixed] = units;
+	return boundedMoney(amount - basisPointsOf(amount, bps, "half-up") - fixed, info);
+}
+//#endregion
+//#region src/commerce/tax.ts
+/**
+* The tax rate in percent that `tax` on `net` implies, snapped half-up to a multiple of `snap`
+* (default 0.5, every real EU VAT rate; 0 = no snap, 10 decimals). `net <= 0` gives 0.
+* sevDesk `inferTaxRatePercent`, exact.
+*/
+function inferTaxRatePercent(net, tax, options = {}) {
+	const { units } = oneCurrency([net, tax], "infer a tax rate from");
+	const [n, t] = units;
+	const snap = percentValue(options.snap ?? .5, "snap");
+	if (snap.units < 0n) throw new MoneyError("amount_invalid", `snap must not be negative, got ${describeValue(options.snap)}`);
+	if (n <= 0n) return 0;
+	if (snap.units === 0n) return Number(toDecimalText(percentRatio(t, n, 10)));
+	const steps = percentRatio(t, n * snap.units, snap.scale).units;
+	return Number(toDecimalText({
+		units: steps * snap.units,
+		scale: snap.scale
+	}));
+}
+/**
+* The rate in percent behind `tax` on `base` (Shopify archive `taxRateFor`): exclusive
+* `100 tax / base`, inclusive `100 tax / (base - tax)`, half-up to `decimals` (default 10),
+* trailing zeros dropped. Null when tax or base is not positive, or the denominator is not.
+*/
+function solveTaxRate(input) {
+	const { units } = oneCurrency([input.tax, input.base], "solve a tax rate from");
+	const [tax, base] = units;
+	const decimals = digitsOf(input.decimals ?? 10);
+	if (tax <= 0n || base <= 0n) return null;
+	const denominator = input.inclusive ? base - tax : base;
+	if (denominator <= 0n) return null;
+	return toDecimalText(percentRatio(tax, denominator, decimals));
+}
+/**
+* Whether prices include tax (Shopify archive `inferTaxesIncluded`): `explicit` wins; a null
+* total or a non-positive tax is exclusive; else inclusive iff
+* `|sub + ship - total| < |sub + ship + tax - total|`.
+*/
+function inferTaxesIncluded(input) {
+	if (typeof input.explicit === "boolean") return input.explicit;
+	const { units } = oneCurrency([
+		input.subtotal,
+		input.shipping,
+		input.tax,
+		...input.total ? [input.total] : []
+	], "compare");
+	const [sub, ship, tax] = units;
+	if (!input.total || tax <= 0n) return false;
+	const total = units[3];
+	const abs = (x) => x < 0n ? -x : x;
+	return abs(sub + ship - total) < abs(sub + ship + tax - total);
+}
+/** `gross x 100 / (100 + rate)` rounded once to a storage unit. */
+function netOf(gross, ratePercent, rounding) {
+	const rate = percentValue(ratePercent, "ratePercent");
+	const whole = hundredPercent(rate.scale);
+	const denominator = whole + rate.units;
+	if (denominator <= 0n) throw new MoneyError("amount_invalid", `A tax rate must be above -100%, got ${describeValue(ratePercent)}`);
+	return mulDiv(BigInt(gross.amount), whole, denominator, rounding);
+}
+/** `gross` split into `net = round(gross x 100 / (100 + rate))` and `tax = gross - net` (net + tax == gross). */
+function splitGross(gross, ratePercent, options = {}) {
+	const { info } = storedDecimal(gross);
+	const net = netOf(gross, ratePercent, options.rounding ?? "half-up");
+	return {
+		net: boundedMoney(net, info),
+		tax: boundedMoney(BigInt(gross.amount) - net, info)
+	};
+}
+/** A unit price without its tax when prices include tax (`round(unit x 100 / (100 + rate))`), else `unit`. */
+function unitNetOfTax(unit, options) {
+	const { info } = storedDecimal(unit);
+	if (!options.taxInclusive) return unit;
+	return boundedMoney(netOf(unit, options.ratePercent, "half-up"), info);
+}
+/**
+* `refund` spread over positions (each a net and its tax): capped at the gross total, split by
+* gross with the largest remainder, then each gross share split into net and tax in the
+* position's proportion (largest remainder). Per row `net + tax == gross`, and the grosses
+* sum to the (capped) refund. Negative amounts throw `amount_invalid`.
+*/
+function allocateWithTax(refund, positions) {
+	const { info, units } = oneCurrency([refund, ...positions.flatMap((p) => [p.net, p.tax])], "allocate");
+	const [total, ...parts] = units;
+	if (total < 0n || parts.some((p) => p < 0n)) throw new MoneyError("amount_invalid", "A refund and its positions must not be negative");
+	const grosses = positions.map((_, i) => parts[2 * i] + parts[2 * i + 1]);
+	const grossSum = grosses.reduce((a, b) => a + b, 0n);
+	return allocateUnits(total < grossSum ? total : grossSum, grosses).map((share, i) => {
+		const [net, tax] = allocateUnits(share, [parts[2 * i], parts[2 * i + 1]]);
+		return {
+			net: boundedMoney(net, info),
+			tax: boundedMoney(tax, info),
+			gross: boundedMoney(share, info)
+		};
+	});
+}
+const INCLUSIVE_KEYS = [
+	"original_item_total",
+	"discount_total",
+	"original_shipping_total",
+	"tax_total",
+	"total"
+];
+const EXCLUSIVE_KEYS = [
+	"item_subtotal",
+	"discount_subtotal",
+	"shipping_subtotal",
+	"tax_total",
+	"total"
+];
+/**
+* The totals a customer-facing summary shows, one selection for every email: tax-inclusive
+* stores show the gross item and shipping totals with the tax "included", exclusive stores the
+* net subtotals with the tax "added". Each field reads `raw_<key>` first, like
+* `readStoredField`; Medusa's fractional totals round half-up to a storage unit; a missing or
+* unreadable field is null, never 0.
+*/
+function displayTotals(totals, currency, options) {
+	const info = resolveCurrency(currency, { allowHistoric: true });
+	const read = (key) => {
+		const exact = readStoredDecimal(storedFieldValue(totals, key), { mode: "lenient" });
+		return exact === null ? null : roundStoredDecimal(decimalOf(exact), info);
+	};
+	const [subtotal, discount, shipping, tax, total] = (options.taxInclusive ? INCLUSIVE_KEYS : EXCLUSIVE_KEYS).map(read);
+	return {
+		subtotal,
+		discount,
+		shipping,
+		tax,
+		total,
+		taxIncluded: options.taxInclusive
+	};
+}
+//#endregion
+export { allocateWithTax, applyMarkup, buyGetReward, discountAmount, displayTotals, formatDiscount, inferTaxRatePercent, inferTaxesIncluded, landedUnitCosts, marginPercent, netOfFee, percentChange, requiresPayment, resolveOrderValue, retailPrice, solveTaxRate, splitGross, storageConventionOf, unitNetOfTax, weightedAverageCost };

package/dist/format-BdPnijvn.js

@@ -0,0 +1,99 @@
+import { B as decimalOf, E as resolveCurrency, M as resolveLocale, Q as MoneyError, at as fractionDigitsOf, dt as roundToScale, it as formatDecimal, j as numberFormat, nt as decimalFromNumber, s as storedDecimal, tt as compareDecimal } from "./money-WhnGiI00.js";
+import { i as roundToUnit } from "./rounding-g9rvye0k.js";
+//#region src/format.ts
+function intlDisplay(options) {
+	const display = options.currencyDisplay ?? "symbol";
+	return display === "symbol+code" ? "symbol" : display;
+}
+function finish(text, code, options) {
+	const withCode = options.currencyDisplay === "symbol+code" && !text.includes(code) ? `${text} ${code}` : text;
+	return options.minusSign === "−" ? withCode.replace("-", "−") : withCode;
+}
+const asIntlValue = (text) => text;
+/**
+* Money for people: `'$1,234.50'`, `'¥1,200'`, `'KWD 1.005'`, `'-€5.00'`. Locale, currency
+* display, digits and sign are explicit options; the active app locale is the caller's to
+* pass. If Intl throws, `'<CODE> <decimal>'`.
+*/
+function formatMoney(m, options = {}) {
+	const { info, value } = storedDecimal(m);
+	const whole = fractionDigitsOf(value) === 0;
+	const digits = options.digits === "widen" ? Math.max(info.displayDigits, fractionDigitsOf(value)) : options.digits === "trim-zero" && whole ? 0 : info.displayDigits;
+	const text = formatDecimal(roundToScale(value, digits, "half-up"));
+	try {
+		return finish(numberFormat(resolveLocale(options.locale), {
+			style: "currency",
+			currency: info.code,
+			currencyDisplay: intlDisplay(options),
+			minimumFractionDigits: digits,
+			maximumFractionDigits: digits,
+			signDisplay: options.signDisplay ?? "auto"
+		}).format(asIntlValue(text)), info.code, options);
+	} catch {
+		return finish(`${info.code} ${text}`, info.code, options);
+	}
+}
+/**
+* A stored amount that may be fractional (a Medusa total, 107.8175; a percentage promotion) for
+* people: rounded half-up to a whole storage unit (`roundToUnit`), then `formatMoney` with `options`.
+* A number must be finite; text is plain decimal; an unknown currency throws `currency_invalid`.
+*/
+function formatStored(amount, currency, options = {}) {
+	return formatMoney(roundToUnit(amount, currency), options);
+}
+function compact(currency, major, options, significant) {
+	return numberFormat(resolveLocale(options.locale), {
+		style: "currency",
+		currency,
+		currencyDisplay: intlDisplay(options),
+		notation: "compact",
+		compactDisplay: "short",
+		maximumSignificantDigits: significant,
+		signDisplay: options.signDisplay ?? "auto"
+	}).format(asIntlValue(major));
+}
+/**
+* Like `formatMoney` below `threshold` major units (default 10000, by magnitude); at or above
+* it, compact short notation with `maximumSignificantDigits` (default 3): `'$12.3K'`.
+*/
+function formatMoneyCompact(m, options = {}) {
+	const { info, value } = storedDecimal(m);
+	const threshold = decimalOf(options.threshold ?? 1e4, false, "threshold");
+	const magnitude = {
+		units: value.units < 0n ? -value.units : value.units,
+		scale: value.scale
+	};
+	if (compareDecimal(magnitude, threshold) < 0) return formatMoney(m, options);
+	try {
+		return finish(compact(info.code, formatDecimal(value), options, options.maximumSignificantDigits ?? 3), info.code, options);
+	} catch {
+		return formatMoney(m, options);
+	}
+}
+/** `'$10.00 – $20.00'` (en dash between spaces), `'$10.00+'` when `high` is null; zero amounts show `zeroLabel` when given. */
+function formatMoneyRange(low, high, options = {}) {
+	const lowCode = storedDecimal(low).info.code;
+	const show = (m) => m.amount === 0 && options.zeroLabel !== void 0 ? options.zeroLabel : formatMoney(m, options);
+	if (high === null) return `${show(low)}+`;
+	const highCode = storedDecimal(high).info.code;
+	if (highCode !== lowCode) throw new MoneyError("currency_mismatch", `Cannot format a range from ${lowCode} to ${highCode}`);
+	return `${show(low)} – ${show(high)}`;
+}
+/**
+* A chart tick formatter for values that already are major units: always compact, with the
+* same rounding as `formatMoneyCompact` (`1234567` gives `'$1.23M'`).
+*/
+function moneyAxisFormatter(currency, options = {}) {
+	const { code } = resolveCurrency(currency, { allowHistoric: true });
+	return (major) => {
+		if (!Number.isFinite(major)) return `${code} ${major}`;
+		const text = formatDecimal(decimalFromNumber(major));
+		try {
+			return finish(compact(code, text, options, 3), code, options);
+		} catch {
+			return `${code} ${text}`;
+		}
+	};
+}
+//#endregion
+export { moneyAxisFormatter as a, formatStored as i, formatMoneyCompact as n, formatMoneyRange as r, formatMoney as t };