monetra 0.0.1

package/dist/index 2.mjs

@@ -0,0 +1,381 @@
+// src/errors/BaseError.ts
+var MonetraError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = this.constructor.name;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+
+// src/errors/CurrencyMismatchError.ts
+var CurrencyMismatchError = class extends MonetraError {
+  constructor(expected, actual) {
+    super(`Currency mismatch: expected ${expected}, got ${actual}`);
+  }
+};
+
+// src/errors/InvalidPrecisionError.ts
+var InvalidPrecisionError = class extends MonetraError {
+  constructor(message) {
+    super(message);
+  }
+};
+
+// src/errors/RoundingRequiredError.ts
+var RoundingRequiredError = class extends MonetraError {
+  constructor() {
+    super("Rounding is required for this operation but was not provided.");
+  }
+};
+
+// src/errors/InsufficientFundsError.ts
+var InsufficientFundsError = class extends MonetraError {
+  constructor() {
+    super("Insufficient funds for this operation.");
+  }
+};
+
+// src/errors/OverflowError.ts
+var OverflowError = class extends MonetraError {
+  constructor(message = "Arithmetic overflow") {
+    super(message);
+  }
+};
+
+// src/money/guards.ts
+function assertSameCurrency(a, b) {
+  if (a.currency.code !== b.currency.code) {
+    throw new CurrencyMismatchError(a.currency.code, b.currency.code);
+  }
+}
+
+// src/rounding/strategies.ts
+var RoundingMode = /* @__PURE__ */ ((RoundingMode3) => {
+  RoundingMode3["HALF_UP"] = "HALF_UP";
+  RoundingMode3["HALF_DOWN"] = "HALF_DOWN";
+  RoundingMode3["HALF_EVEN"] = "HALF_EVEN";
+  RoundingMode3["FLOOR"] = "FLOOR";
+  RoundingMode3["CEIL"] = "CEIL";
+  return RoundingMode3;
+})(RoundingMode || {});
+
+// src/rounding/index.ts
+function divideWithRounding(numerator, denominator, mode) {
+  if (denominator === 0n) {
+    throw new Error("Division by zero");
+  }
+  const quotient = numerator / denominator;
+  const remainder = numerator % denominator;
+  if (remainder === 0n) {
+    return quotient;
+  }
+  const sign = (numerator >= 0n ? 1n : -1n) * (denominator >= 0n ? 1n : -1n);
+  const absRemainder = remainder < 0n ? -remainder : remainder;
+  const absDenominator = denominator < 0n ? -denominator : denominator;
+  const isHalf = absRemainder * 2n === absDenominator;
+  const isMoreThanHalf = absRemainder * 2n > absDenominator;
+  switch (mode) {
+    case "FLOOR" /* FLOOR */:
+      return sign > 0n ? quotient : quotient - 1n;
+    case "CEIL" /* CEIL */:
+      return sign > 0n ? quotient + 1n : quotient;
+    case "HALF_UP" /* HALF_UP */:
+      if (isMoreThanHalf || isHalf) {
+        return sign > 0n ? quotient + 1n : quotient - 1n;
+      }
+      return quotient;
+    case "HALF_DOWN" /* HALF_DOWN */:
+      if (isMoreThanHalf) {
+        return sign > 0n ? quotient + 1n : quotient - 1n;
+      }
+      return quotient;
+    case "HALF_EVEN" /* HALF_EVEN */:
+      if (isMoreThanHalf) {
+        return sign > 0n ? quotient + 1n : quotient - 1n;
+      }
+      if (isHalf) {
+        if (quotient % 2n !== 0n) {
+          return sign > 0n ? quotient + 1n : quotient - 1n;
+        }
+      }
+      return quotient;
+    default:
+      throw new Error(`Unsupported rounding mode: ${mode}`);
+  }
+}
+
+// src/money/arithmetic.ts
+function add(a, b) {
+  return a + b;
+}
+function subtract(a, b) {
+  return a - b;
+}
+function multiply(amount, multiplier, rounding) {
+  const { numerator, denominator } = parseMultiplier(multiplier);
+  const product = amount * numerator;
+  if (product % denominator === 0n) {
+    return product / denominator;
+  }
+  if (!rounding) {
+    throw new RoundingRequiredError();
+  }
+  return divideWithRounding(product, denominator, rounding);
+}
+function parseMultiplier(multiplier) {
+  const s = multiplier.toString();
+  if (/[eE]/.test(s)) {
+    throw new Error("Scientific notation not supported");
+  }
+  const parts = s.split(".");
+  if (parts.length > 2) {
+    throw new Error("Invalid number format");
+  }
+  const integerPart = parts[0];
+  const fractionalPart = parts[1] || "";
+  const denominator = 10n ** BigInt(fractionalPart.length);
+  const numerator = BigInt(integerPart + fractionalPart);
+  return { numerator, denominator };
+}
+
+// src/money/allocation.ts
+function allocate(amount, ratios) {
+  if (ratios.length === 0) {
+    throw new Error("Cannot allocate to empty ratios");
+  }
+  const scaledRatios = ratios.map((r) => {
+    const s = r.toString();
+    if (/[eE]/.test(s)) throw new Error("Scientific notation not supported");
+    const parts = s.split(".");
+    const decimals = parts[1] ? parts[1].length : 0;
+    const value = BigInt(parts[0] + (parts[1] || ""));
+    return { value, decimals };
+  });
+  const maxDecimals = Math.max(...scaledRatios.map((r) => r.decimals));
+  const normalizedRatios = scaledRatios.map((r) => {
+    const factor = 10n ** BigInt(maxDecimals - r.decimals);
+    return r.value * factor;
+  });
+  const total = normalizedRatios.reduce((sum, r) => sum + r, 0n);
+  if (total === 0n) {
+    throw new Error("Total ratio must be greater than zero");
+  }
+  const results = [];
+  let allocatedTotal = 0n;
+  for (let i = 0; i < normalizedRatios.length; i++) {
+    const ratio = normalizedRatios[i];
+    const share = amount * ratio / total;
+    const remainder = amount * ratio % total;
+    results.push({ share, remainder, index: i });
+    allocatedTotal += share;
+  }
+  let leftOver = amount - allocatedTotal;
+  results.sort((a, b) => {
+    if (b.remainder > a.remainder) return 1;
+    if (b.remainder < a.remainder) return -1;
+    return 0;
+  });
+  for (let i = 0; i < Number(leftOver); i++) {
+    results[i].share += 1n;
+  }
+  results.sort((a, b) => a.index - b.index);
+  return results.map((r) => r.share);
+}
+
+// src/format/parser.ts
+function parseToMinor(amount, currency) {
+  if (/[eE]/.test(amount)) {
+    throw new Error("Scientific notation not supported");
+  }
+  if (/[^0-9.-]/.test(amount)) {
+    throw new Error("Invalid characters in amount");
+  }
+  const parts = amount.split(".");
+  if (parts.length > 2) {
+    throw new Error("Invalid format: multiple decimal points");
+  }
+  const integerPart = parts[0];
+  const fractionalPart = parts[1] || "";
+  if (fractionalPart.length > currency.decimals) {
+    throw new InvalidPrecisionError(
+      `Precision ${fractionalPart.length} exceeds currency decimals ${currency.decimals}`
+    );
+  }
+  const paddedFractional = fractionalPart.padEnd(currency.decimals, "0");
+  const combined = integerPart + paddedFractional;
+  if (combined === "-" || combined === "") {
+    throw new Error("Invalid format");
+  }
+  return BigInt(combined);
+}
+
+// src/format/formatter.ts
+function format(money, options) {
+  const locale = options?.locale || money.currency.locale || "en-US";
+  const showSymbol = options?.symbol ?? true;
+  const decimals = money.currency.decimals;
+  const minor = money.minor;
+  const absMinor = minor < 0n ? -minor : minor;
+  const divisor = 10n ** BigInt(decimals);
+  const integerPart = absMinor / divisor;
+  const fractionalPart = absMinor % divisor;
+  const fractionalStr = fractionalPart.toString().padStart(decimals, "0");
+  const parts = new Intl.NumberFormat(locale, {
+    style: "decimal",
+    minimumFractionDigits: 1
+  }).formatToParts(1.1);
+  const decimalSeparator = parts.find((p) => p.type === "decimal")?.value || ".";
+  const integerFormatted = new Intl.NumberFormat(locale, {
+    style: "decimal",
+    useGrouping: true
+  }).format(integerPart);
+  const absString = decimals > 0 ? `${integerFormatted}${decimalSeparator}${fractionalStr}` : integerFormatted;
+  if (!showSymbol) {
+    return minor < 0n ? `-${absString}` : absString;
+  }
+  const templateParts = new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency: money.currency.code
+  }).formatToParts(minor < 0n ? -1 : 1);
+  let result = "";
+  let numberInserted = false;
+  for (const part of templateParts) {
+    if (["integer", "group", "decimal", "fraction"].includes(part.type)) {
+      if (!numberInserted) {
+        result += absString;
+        numberInserted = true;
+      }
+    } else if (part.type === "currency") {
+      result += part.value;
+    } else {
+      result += part.value;
+    }
+  }
+  return result;
+}
+
+// src/money/Money.ts
+var Money = class _Money {
+  constructor(minor, currency) {
+    this.minor = minor;
+    this.currency = currency;
+  }
+  static fromMinor(minor, currency) {
+    return new _Money(BigInt(minor), currency);
+  }
+  static fromMajor(amount, currency) {
+    const minor = parseToMinor(amount, currency);
+    return new _Money(minor, currency);
+  }
+  static zero(currency) {
+    return new _Money(0n, currency);
+  }
+  add(other) {
+    assertSameCurrency(this, other);
+    return new _Money(add(this.minor, other.minor), this.currency);
+  }
+  subtract(other) {
+    assertSameCurrency(this, other);
+    return new _Money(subtract(this.minor, other.minor), this.currency);
+  }
+  multiply(multiplier, options) {
+    const result = multiply(this.minor, multiplier, options?.rounding);
+    return new _Money(result, this.currency);
+  }
+  allocate(ratios) {
+    const shares = allocate(this.minor, ratios);
+    return shares.map((share) => new _Money(share, this.currency));
+  }
+  format(options) {
+    return format(this, options);
+  }
+  equals(other) {
+    return this.currency.code === other.currency.code && this.minor === other.minor;
+  }
+  greaterThan(other) {
+    assertSameCurrency(this, other);
+    return this.minor > other.minor;
+  }
+  lessThan(other) {
+    assertSameCurrency(this, other);
+    return this.minor < other.minor;
+  }
+  isZero() {
+    return this.minor === 0n;
+  }
+  isNegative() {
+    return this.minor < 0n;
+  }
+};
+
+// src/currency/iso4217.ts
+var USD = {
+  code: "USD",
+  decimals: 2,
+  symbol: "$",
+  locale: "en-US"
+};
+var EUR = {
+  code: "EUR",
+  decimals: 2,
+  symbol: "\u20AC",
+  locale: "de-DE"
+  // Default locale, can be overridden
+};
+var GBP = {
+  code: "GBP",
+  decimals: 2,
+  symbol: "\xA3",
+  locale: "en-GB"
+};
+var JPY = {
+  code: "JPY",
+  decimals: 0,
+  symbol: "\xA5",
+  locale: "ja-JP"
+};
+var ZAR = {
+  code: "ZAR",
+  decimals: 2,
+  symbol: "R",
+  locale: "en-ZA"
+};
+var CURRENCIES = {
+  USD,
+  EUR,
+  GBP,
+  JPY,
+  ZAR
+};
+function getCurrency(code) {
+  const currency = CURRENCIES[code.toUpperCase()];
+  if (!currency) {
+    throw new Error(`Unknown currency code: ${code}`);
+  }
+  return currency;
+}
+
+// src/currency/precision.ts
+function getMinorUnitExponent(currency) {
+  return 10n ** BigInt(currency.decimals);
+}
+export {
+  CURRENCIES,
+  CurrencyMismatchError,
+  EUR,
+  GBP,
+  InsufficientFundsError,
+  InvalidPrecisionError,
+  JPY,
+  MonetraError,
+  Money,
+  OverflowError,
+  RoundingMode,
+  RoundingRequiredError,
+  USD,
+  ZAR,
+  divideWithRounding,
+  getCurrency,
+  getMinorUnitExponent
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.d 2.mts

@@ -0,0 +1,76 @@
+interface Currency {
+    code: string;
+    decimals: number;
+    symbol: string;
+    locale?: string;
+}
+
+declare enum RoundingMode {
+    HALF_UP = "HALF_UP",
+    HALF_DOWN = "HALF_DOWN",
+    HALF_EVEN = "HALF_EVEN",
+    FLOOR = "FLOOR",
+    CEIL = "CEIL"
+}
+
+declare class Money {
+    readonly minor: bigint;
+    readonly currency: Currency;
+    private constructor();
+    static fromMinor(minor: bigint | number, currency: Currency): Money;
+    static fromMajor(amount: string, currency: Currency): Money;
+    static zero(currency: Currency): Money;
+    add(other: Money): Money;
+    subtract(other: Money): Money;
+    multiply(multiplier: string | number, options?: {
+        rounding?: RoundingMode;
+    }): Money;
+    allocate(ratios: number[]): Money[];
+    format(options?: {
+        locale?: string;
+        symbol?: boolean;
+    }): string;
+    equals(other: Money): boolean;
+    greaterThan(other: Money): boolean;
+    lessThan(other: Money): boolean;
+    isZero(): boolean;
+    isNegative(): boolean;
+}
+
+declare const USD: Currency;
+declare const EUR: Currency;
+declare const GBP: Currency;
+declare const JPY: Currency;
+declare const ZAR: Currency;
+declare const CURRENCIES: Record<string, Currency>;
+declare function getCurrency(code: string): Currency;
+
+declare function getMinorUnitExponent(currency: Currency): bigint;
+
+declare function divideWithRounding(numerator: bigint, denominator: bigint, mode: RoundingMode): bigint;
+
+declare class MonetraError extends Error {
+    constructor(message: string);
+}
+
+declare class CurrencyMismatchError extends MonetraError {
+    constructor(expected: string, actual: string);
+}
+
+declare class InvalidPrecisionError extends MonetraError {
+    constructor(message: string);
+}
+
+declare class RoundingRequiredError extends MonetraError {
+    constructor();
+}
+
+declare class InsufficientFundsError extends MonetraError {
+    constructor();
+}
+
+declare class OverflowError extends MonetraError {
+    constructor(message?: string);
+}
+
+export { CURRENCIES, type Currency, CurrencyMismatchError, EUR, GBP, InsufficientFundsError, InvalidPrecisionError, JPY, MonetraError, Money, OverflowError, RoundingMode, RoundingRequiredError, USD, ZAR, divideWithRounding, getCurrency, getMinorUnitExponent };

package/dist/index.d 2.ts

@@ -0,0 +1,76 @@
+interface Currency {
+    code: string;
+    decimals: number;
+    symbol: string;
+    locale?: string;
+}
+
+declare enum RoundingMode {
+    HALF_UP = "HALF_UP",
+    HALF_DOWN = "HALF_DOWN",
+    HALF_EVEN = "HALF_EVEN",
+    FLOOR = "FLOOR",
+    CEIL = "CEIL"
+}
+
+declare class Money {
+    readonly minor: bigint;
+    readonly currency: Currency;
+    private constructor();
+    static fromMinor(minor: bigint | number, currency: Currency): Money;
+    static fromMajor(amount: string, currency: Currency): Money;
+    static zero(currency: Currency): Money;
+    add(other: Money): Money;
+    subtract(other: Money): Money;
+    multiply(multiplier: string | number, options?: {
+        rounding?: RoundingMode;
+    }): Money;
+    allocate(ratios: number[]): Money[];
+    format(options?: {
+        locale?: string;
+        symbol?: boolean;
+    }): string;
+    equals(other: Money): boolean;
+    greaterThan(other: Money): boolean;
+    lessThan(other: Money): boolean;
+    isZero(): boolean;
+    isNegative(): boolean;
+}
+
+declare const USD: Currency;
+declare const EUR: Currency;
+declare const GBP: Currency;
+declare const JPY: Currency;
+declare const ZAR: Currency;
+declare const CURRENCIES: Record<string, Currency>;
+declare function getCurrency(code: string): Currency;
+
+declare function getMinorUnitExponent(currency: Currency): bigint;
+
+declare function divideWithRounding(numerator: bigint, denominator: bigint, mode: RoundingMode): bigint;
+
+declare class MonetraError extends Error {
+    constructor(message: string);
+}
+
+declare class CurrencyMismatchError extends MonetraError {
+    constructor(expected: string, actual: string);
+}
+
+declare class InvalidPrecisionError extends MonetraError {
+    constructor(message: string);
+}
+
+declare class RoundingRequiredError extends MonetraError {
+    constructor();
+}
+
+declare class InsufficientFundsError extends MonetraError {
+    constructor();
+}
+
+declare class OverflowError extends MonetraError {
+    constructor(message?: string);
+}
+
+export { CURRENCIES, type Currency, CurrencyMismatchError, EUR, GBP, InsufficientFundsError, InvalidPrecisionError, JPY, MonetraError, Money, OverflowError, RoundingMode, RoundingRequiredError, USD, ZAR, divideWithRounding, getCurrency, getMinorUnitExponent };