@classytic/primitives 0.26.4 → 0.28.0

package/dist/money.mjs

@@ -1,177 +1,3 @@
-import { CurrencyMismatchError, currencyCode, isCurrencyCode, minorUnitFactor } from "./currency.mjs";
-//#region src/money/money.ts
-/**
-* Cast a raw number to {@link MinorUnits}. Pass the currency as the second
-* argument to fix the phantom type. With no second arg, `MinorUnits<string>`
-* — useful for generic SDK boundaries that don't know the currency yet.
-*
-* @example
-* MinorUnits(489900, 'BDT')   // typed MinorUnits<'BDT'>
-* MinorUnits(199, 'USD')      // typed MinorUnits<'USD'>
-*/
-function MinorUnits(amount, _currency) {
-	return amount;
-}
-/**
-* Construct {@link Money} from an integer minor-unit amount.
-*
-* @throws TypeError if `amount` is not a finite integer.
-* @throws InvalidCurrencyCodeError if `currency` is not ISO 4217 format.
-*/
-function money(amount, currency) {
-	if (!Number.isFinite(amount) || !Number.isInteger(amount)) throw new TypeError(`Money.amount must be a finite integer in minor units, got ${amount}`);
-	return {
-		amount,
-		currency: currencyCode(currency)
-	};
-}
-/**
-* Construct {@link Money} from a major-unit number (e.g. dollars, taka) by
-* scaling to the currency's minor unit and rounding half-away-from-zero.
-*
-* Uses `toPrecision(15)` to strip the trailing-bit noise that appears in
-* multiply-then-round (e.g. `0.1 + 0.2 = 0.30000000000000004`). This is
-* enough for the vast majority of decimals encountered in real-world pricing.
-*
-* **Precision caveat.** A handful of decimals cannot be represented exactly
-* in IEEE 754 and will round to the IEEE-closest integer rather than the
-* mathematically-expected one — e.g. `1.005` is stored as `1.00499999…` and
-* rounds to `100` minor units, not `101`. If you need decimal-exact rounding,
-* construct money from a string or use integer minor units directly via
-* {@link money}.
-*
-* @example
-* fromMajor(19.99, 'USD')      // { amount: 1999, currency: 'USD' }
-* fromMajor(0.1 + 0.2, 'USD')  // { amount: 30,   currency: 'USD' }
-* fromMajor(1500,  'JPY')      // { amount: 1500, currency: 'JPY' }
-*/
-function fromMajor(major, currency) {
-	if (!Number.isFinite(major)) throw new TypeError(`fromMajor received non-finite value: ${major}`);
-	const raw = major * minorUnitFactor(currency);
-	const cleaned = Number(raw.toPrecision(15));
-	return {
-		amount: Math.round(Math.abs(cleaned)) * (cleaned < 0 ? -1 : 1),
-		currency: currencyCode(currency)
-	};
-}
-/** Convert {@link Money} back to its major-unit floating-point representation. */
-function toMajor(m) {
-	return m.amount / minorUnitFactor(m.currency);
-}
-function assertSameCurrency(a, b) {
-	if (a.currency !== b.currency) throw new CurrencyMismatchError(a.currency, b.currency);
-}
-function addMoney(a, b) {
-	assertSameCurrency(a, b);
-	return {
-		amount: a.amount + b.amount,
-		currency: a.currency
-	};
-}
-function subtractMoney(a, b) {
-	assertSameCurrency(a, b);
-	return {
-		amount: a.amount - b.amount,
-		currency: a.currency
-	};
-}
-/**
-* Multiply money by a scalar. The result is rounded to an integer number of
-* minor units using half-away-from-zero rounding.
-*/
-function multiplyMoney(m, scalar) {
-	if (!Number.isFinite(scalar)) throw new TypeError(`multiplyMoney received non-finite scalar: ${scalar}`);
-	const raw = m.amount * scalar;
-	return {
-		amount: Math.round(Math.abs(raw)) * (raw < 0 ? -1 : 1),
-		currency: m.currency
-	};
-}
-/** Sum a list of {@link Money}. Returns zero in the given currency for empty input. */
-function sumMoney(values, currency) {
-	return values.reduce((acc, v) => addMoney(acc, v), {
-		amount: 0,
-		currency: currencyCode(currency)
-	});
-}
-/** Strict equality (amount and currency both match). */
-function equalsMoney(a, b) {
-	return a.amount === b.amount && a.currency === b.currency;
-}
-/**
-* Ordering predicate. Returns -1, 0, or 1. Throws on currency mismatch — use
-* {@link equalsMoney} for a total equality check across currencies.
-*/
-function compareMoney(a, b) {
-	assertSameCurrency(a, b);
-	if (a.amount < b.amount) return -1;
-	if (a.amount > b.amount) return 1;
-	return 0;
-}
-function isZeroMoney(m) {
-	return m.amount === 0;
-}
-function isPositiveMoney(m) {
-	return m.amount > 0;
-}
-function isNegativeMoney(m) {
-	return m.amount < 0;
-}
-function negateMoney(m) {
-	return {
-		amount: m.amount === 0 ? 0 : -m.amount,
-		currency: m.currency
-	};
-}
-function absMoney(m) {
-	return m.amount < 0 ? negateMoney(m) : m;
-}
-/**
-* Decimal major-unit number → integer minor units by decimal exponent.
-* Rounding: raw IEEE `Math.round` — half-up toward +∞ (so `-10.5 → -10`),
-* documented above. Throws when the result leaves the safe-integer range
-* (also catches `NaN`/`Infinity` inputs).
-*
-* @example
-* majorToMinorUnits(10.5)      // 1050
-* majorToMinorUnits(1000, 0)   // 1000 (JPY-style)
-* majorToMinorUnits(1.005)     // 100 — IEEE, see note above
-*/
-function majorToMinorUnits(major, minorUnitDecimals = 2) {
-	const factor = 10 ** minorUnitDecimals;
-	const minor = Math.round(major * factor);
-	if (!Number.isSafeInteger(minor)) throw new RangeError(`Amount ${major} exceeds safe integer limit when converted to minor units. Max safe amount: ${Number.MAX_SAFE_INTEGER / factor}`);
-	return minor;
-}
-/** Integer minor units → decimal major-unit number by decimal exponent: `1050 → 10.5`. */
-function minorUnitsToMajor(minor, minorUnitDecimals = 2) {
-	return minor / 10 ** minorUnitDecimals;
-}
-/**
-* Percentage of an integer minor-unit amount → integer minor units.
-* EXACT multiply-then-round: `Math.round((minor × ratePercent) / 100)` —
-* one rounding point, half-up toward +∞. Handles genuinely fractional rates
-* (QST 9.975 %) without precision loss: `percentOfMinor(20000, 9.975) === 1995`.
-*
-* Hosts whose domain guarantees at-most-2-decimal rates MAY snap the rate to
-* integer basis points BEFORE calling (be-prod's `#shared/money` seam does) —
-* that is host policy layered on top, not part of this primitive.
-*/
-function percentOfMinor(minor, ratePercent) {
-	if (!Number.isFinite(minor) || !Number.isFinite(ratePercent)) throw new TypeError(`percentOfMinor received non-finite input: minor=${minor}, ratePercent=${ratePercent}`);
-	return Math.round(minor * ratePercent / 100);
-}
-/**
-* Integer minor units → plain decimal string (no currency symbol, no locale):
-* `formatMinorUnits(10550) → "105.50"`, `formatMinorUnits(1000, 0) → "1000"`.
-* For localized currency strings use `Intl.NumberFormat` at the display layer.
-*/
-function formatMinorUnits(minor, minorUnitDecimals = 2) {
-	return minorUnitsToMajor(minor, minorUnitDecimals).toFixed(minorUnitDecimals);
-}
-/** Structural type guard. */
-function isMoney(value) {
-	return typeof value === "object" && value !== null && typeof value.amount === "number" && Number.isInteger(value.amount) && isCurrencyCode(value.currency);
-}
-//#endregion
-export { CurrencyMismatchError, MinorUnits, absMoney, addMoney, compareMoney, equalsMoney, formatMinorUnits, fromMajor, isMoney, isNegativeMoney, isPositiveMoney, isZeroMoney, majorToMinorUnits, minorUnitsToMajor, money, multiplyMoney, negateMoney, percentOfMinor, subtractMoney, sumMoney, toMajor };
+import { CurrencyMismatchError } from "./currency.mjs";
+import { C as isCashDestination, S as cashDestinationLabel, _ as percentOfMinor, a as equalsMoney, b as toMajor, c as isMoney, d as isZeroMoney, f as majorToMinorUnits, g as negateMoney, h as multiplyMoney, i as compareMoney, l as isNegativeMoney, m as money, n as absMoney, o as formatMinorUnits, p as minorUnitsToMajor, r as addMoney, s as fromMajor, t as MinorUnits, u as isPositiveMoney, v as subtractMoney, x as CASH_DESTINATIONS, y as sumMoney } from "./money-BBOARE5f.mjs";
+export { CASH_DESTINATIONS, CurrencyMismatchError, MinorUnits, absMoney, addMoney, cashDestinationLabel, compareMoney, equalsMoney, formatMinorUnits, fromMajor, isCashDestination, isMoney, isNegativeMoney, isPositiveMoney, isZeroMoney, majorToMinorUnits, minorUnitsToMajor, money, multiplyMoney, negateMoney, percentOfMinor, subtractMoney, sumMoney, toMajor };

package/dist/payment-events.d.mts

@@ -1,4 +1,4 @@
-import { n as Money } from "./money-CfAvfNiM.mjs";
+import { n as Money } from "./money-C9iLWiWR.mjs";
 import { PaymentMethodKind } from "./payment-method-kind.mjs";
 import { ProviderUnknownCause } from "./payment-gateway.mjs";
 //#region src/events/payment-events.d.ts

package/dist/payment-gateway.d.mts

@@ -1,4 +1,4 @@
-import { n as Money } from "./money-CfAvfNiM.mjs";
+import { n as Money } from "./money-C9iLWiWR.mjs";
 import { PaymentMethodKind } from "./payment-method-kind.mjs";
 //#region src/money/payment-gateway.d.ts
 /**

package/dist/proration.d.mts

@@ -1,4 +1,4 @@
-import { n as Money } from "./money-CfAvfNiM.mjs";
+import { n as Money } from "./money-C9iLWiWR.mjs";
 //#region src/money/proration.d.ts
 /**
  * How to count days within a period.

package/dist/unit-cost-rate.d.mts

@@ -1,4 +1,4 @@
-import { t as MinorUnits, w as CurrencyCode } from "./money-CfAvfNiM.mjs";
+import { O as CurrencyCode, t as MinorUnits } from "./money-C9iLWiWR.mjs";
 //#region src/money/rounded-div.d.ts
 type RoundingMode = 'half-even' | 'half-up';
 //#endregion

package/dist/unit-cost-rate.mjs

@@ -1,4 +1,4 @@
-import { MinorUnits } from "./money.mjs";
+import { t as MinorUnits } from "./money-BBOARE5f.mjs";
 import { t as roundedDiv } from "./rounded-div-BWJb98Ws.mjs";
 //#region src/money/unit-cost-rate.ts
 /** Fixed, ecosystem-wide rate scale: 6 decimal places below the minor unit. */