monetra 2.0.0 → 2.2.0

package/dist/index.js

@@ -49,6 +49,7 @@ __export(index_exports, {
   INR: () => INR,
   ISK: () => ISK,
   InsufficientFundsError: () => InsufficientFundsError,
+  InvalidArgumentError: () => InvalidArgumentError,
   InvalidPrecisionError: () => InvalidPrecisionError,
   JOD: () => JOD,
   JPY: () => JPY,
@@ -95,16 +96,24 @@ __export(index_exports, {
   assertNonNegative: () => assertNonNegative,
   assertSameCurrency: () => assertSameCurrency,
   compound: () => compound,
+  currentYield: () => currentYield,
+  debtToAssets: () => debtToAssets,
+  debtToEquity: () => debtToEquity,
   discount: () => discount,
   divideWithRounding: () => divideWithRounding,
+  equityMultiplier: () => equityMultiplier,
   format: () => format,
   futureValue: () => futureValue,
   generateHash: () => generateHash,
   generateHashSync: () => generateHashSync,
+  getAllCurrencies: () => getAllCurrencies,
   getCurrency: () => getCurrency,
   getMinorUnitExponent: () => getMinorUnitExponent,
+  interestCoverage: () => interestCoverage,
+  interestOnlyPayment: () => interestOnlyPayment,
   irr: () => irr,
   isCurrencyRegistered: () => isCurrencyRegistered,
+  leverageRatios: () => leverageRatios,
   loan: () => loan,
   money: () => money,
   npv: () => npv,
@@ -114,7 +123,13 @@ __export(index_exports, {
   pmt: () => pmt,
   presentValue: () => presentValue,
   registerCurrency: () => registerCurrency,
+  roi: () => roi,
   setHashFunction: () => setHashFunction,
+  simpleInterest: () => simpleInterest,
+  simpleInterestTotal: () => simpleInterestTotal,
+  straightLineDepreciation: () => straightLineDepreciation,
+  totalInterest: () => totalInterest,
+  totalInterestFromSchedule: () => totalInterestFromSchedule,
   verifyChain: () => verifyChain,
   verifyChainSync: () => verifyChainSync
 });
@@ -135,6 +150,9 @@ function getCurrency(code) {
 function isCurrencyRegistered(code) {
   return registry.has(code);
 }
+function getAllCurrencies() {
+  return Object.fromEntries(registry);
+}
 
 // src/rounding/strategies.ts
 var RoundingMode = /* @__PURE__ */ ((RoundingMode3) => {
@@ -151,6 +169,7 @@ var RoundingMode = /* @__PURE__ */ ((RoundingMode3) => {
 var MonetraErrorCode = /* @__PURE__ */ ((MonetraErrorCode2) => {
   MonetraErrorCode2["CURRENCY_MISMATCH"] = "MONETRA_CURRENCY_MISMATCH";
   MonetraErrorCode2["INSUFFICIENT_FUNDS"] = "MONETRA_INSUFFICIENT_FUNDS";
+  MonetraErrorCode2["INVALID_ARGUMENT"] = "MONETRA_INVALID_ARGUMENT";
   MonetraErrorCode2["INVALID_PRECISION"] = "MONETRA_INVALID_PRECISION";
   MonetraErrorCode2["OVERFLOW"] = "MONETRA_OVERFLOW";
   MonetraErrorCode2["ROUNDING_REQUIRED"] = "MONETRA_ROUNDING_REQUIRED";
@@ -211,6 +230,13 @@ var InsufficientFundsError = class extends MonetraError {
   }
 };
 
+// src/errors/InvalidArgumentError.ts
+var InvalidArgumentError = class extends MonetraError {
+  constructor(message) {
+    super(message, "MONETRA_INVALID_ARGUMENT" /* INVALID_ARGUMENT */);
+  }
+};
+
 // src/errors/OverflowError.ts
 var OverflowError = class extends MonetraError {
   constructor(message = "Arithmetic overflow") {
@@ -240,33 +266,34 @@ function divideWithRounding(numerator, denominator, mode) {
   if (remainder === 0n) {
     return quotient;
   }
-  const sign = (numerator >= 0n ? 1n : -1n) * (denominator >= 0n ? 1n : -1n);
+  const isNegativeResult = numerator < 0n !== denominator < 0n;
+  const isPositiveResult = !isNegativeResult;
   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;
+      return isPositiveResult ? quotient : quotient - 1n;
     case "CEIL" /* CEIL */:
-      return sign > 0n ? quotient + 1n : quotient;
+      return isPositiveResult ? quotient + 1n : quotient;
     case "HALF_UP" /* HALF_UP */:
       if (isMoreThanHalf || isHalf) {
-        return sign > 0n ? quotient + 1n : quotient - 1n;
+        return isPositiveResult ? quotient + 1n : quotient - 1n;
       }
       return quotient;
     case "HALF_DOWN" /* HALF_DOWN */:
       if (isMoreThanHalf) {
-        return sign > 0n ? quotient + 1n : quotient - 1n;
+        return isPositiveResult ? quotient + 1n : quotient - 1n;
       }
       return quotient;
     case "HALF_EVEN" /* HALF_EVEN */:
       if (isMoreThanHalf) {
-        return sign > 0n ? quotient + 1n : quotient - 1n;
+        return isPositiveResult ? quotient + 1n : quotient - 1n;
       }
       if (isHalf) {
         if (quotient % 2n !== 0n) {
-          return sign > 0n ? quotient + 1n : quotient - 1n;
+          return isPositiveResult ? quotient + 1n : quotient - 1n;
         }
       }
       return quotient;
@@ -305,7 +332,10 @@ function divide(amount, divisor, rounding) {
     return product / numerator;
   }
   if (!rounding) {
-    throw new RoundingRequiredError("divide", Number(product) / Number(numerator));
+    throw new RoundingRequiredError(
+      "divide",
+      Number(product) / Number(numerator)
+    );
   }
   return divideWithRounding(product, numerator, rounding);
 }
@@ -393,11 +423,8 @@ function parseLocaleString(amount, options) {
   let normalized = amount.replace(/[^\d.,\-\s]/g, "").trim();
   const isNegative = normalized.startsWith("-") || amount.includes("(");
   normalized = normalized.replace(/[-()]/g, "");
-  const groupRegex = new RegExp(`\\${groupSeparator}`, "g");
-  normalized = normalized.replace(groupRegex, "");
-  if (decimalSeparator !== ".") {
-    normalized = normalized.replace(decimalSeparator, ".");
-  }
+  normalized = normalized.split(groupSeparator).join("");
+  normalized = normalized.split(decimalSeparator).join(".");
   return isNegative ? `-${normalized}` : normalized;
 }
 function parseLocaleToMinor(amount, currency, options) {
@@ -411,6 +438,9 @@ function parseToMinor(amount, currency) {
   if (/[^0-9.-]/.test(amount)) {
     throw new Error("Invalid characters in amount");
   }
+  if (!/[0-9]/.test(amount)) {
+    throw new Error("Invalid format");
+  }
   const parts = amount.split(".");
   if (parts.length > 2) {
     throw new Error("Invalid format: multiple decimal points");
@@ -424,9 +454,6 @@ function parseToMinor(amount, currency) {
   }
   const paddedFractional = fractionalPart.padEnd(currency.decimals, "0");
   const combined = integerPart + paddedFractional;
-  if (combined === "-" || combined === "") {
-    throw new Error("Invalid format");
-  }
   return BigInt(combined);
 }
 
@@ -466,7 +493,7 @@ function format(money2, options) {
       style: "currency",
       currency: money2.currency.code,
       currencyDisplay: display
-    }).formatToParts(isNegative ? -1 : 1);
+    }).formatToParts(isNegative ? -1234.5 : 1234.5);
   } catch (e) {
     const symbol = display === "symbol" ? money2.currency.symbol : money2.currency.code;
     if (isNegative) {
@@ -476,28 +503,39 @@ function format(money2, options) {
   }
   let result = "";
   let numberInserted = false;
-  let hasMinusSign = false;
   for (const part of templateParts) {
-    if (part.type === "minusSign") {
-      hasMinusSign = true;
-      if (!useAccounting) {
-        result += part.value;
+    switch (part.type) {
+      case "minusSign": {
+        if (!useAccounting) {
+          result += part.value;
+        }
+        break;
       }
-      continue;
-    }
-    if (["integer", "group", "decimal", "fraction"].includes(part.type)) {
-      if (!numberInserted) {
-        result += absString;
-        numberInserted = true;
+      case "integer": {
+        if (!numberInserted) {
+          result += absString;
+          numberInserted = true;
+        }
+        break;
+      }
+      // Skip the remaining numeric parts, since we already inserted the full number string.
+      case "group":
+      case "decimal":
+      case "fraction": {
+        break;
       }
-    } else if (part.type === "currency") {
-      if (display === "symbol" && money2.currency.symbol) {
-        result += money2.currency.symbol;
-      } else {
+      case "currency": {
+        if (display === "symbol" && money2.currency.symbol) {
+          result += money2.currency.symbol;
+        } else {
+          result += part.value;
+        }
+        break;
+      }
+      default: {
         result += part.value;
+        break;
       }
-    } else {
-      result += part.value;
     }
   }
   if (useAccounting && isNegative) {
@@ -696,10 +734,7 @@ var Money = class _Money {
    * @returns A new Money instance with the absolute value.
    */
   abs() {
-    return new _Money(
-      this.minor < 0n ? -this.minor : this.minor,
-      this.currency
-    );
+    return new _Money(this.minor < 0n ? -this.minor : this.minor, this.currency);
   }
   /**
    * Returns the negated value of this Money.
@@ -1588,6 +1623,43 @@ function pmt(options) {
   const schedule = loan(options);
   return schedule[0].payment;
 }
+function totalInterest(options) {
+  const {
+    principal,
+    annualRate,
+    periods,
+    rounding = "HALF_EVEN" /* HALF_EVEN */
+  } = options;
+  if (annualRate === 0) {
+    return Money.zero(principal.currency);
+  }
+  const payment = pmt(options);
+  const totalPaid = payment.multiply(periods, { rounding });
+  return totalPaid.subtract(principal);
+}
+function totalInterestFromSchedule(schedule) {
+  if (schedule.length === 0) {
+    throw new Error("Schedule must have at least one entry");
+  }
+  const currency = schedule[0].interest.currency;
+  return schedule.reduce(
+    (sum, entry) => sum.add(entry.interest),
+    Money.zero(currency)
+  );
+}
+function interestOnlyPayment(options) {
+  const {
+    principal,
+    annualRate,
+    periodsPerYear = 12,
+    rounding = "HALF_EVEN" /* HALF_EVEN */
+  } = options;
+  if (annualRate === 0) {
+    return Money.zero(principal.currency);
+  }
+  const periodicRate = annualRate / periodsPerYear;
+  return principal.multiply(periodicRate, { rounding });
+}
 
 // src/financial/compound.ts
 function futureValue(presentValue2, options) {
@@ -1618,6 +1690,16 @@ var compound = futureValue;
 var discount = presentValue;
 
 // src/financial/investment.ts
+function roi(initialValue, finalValue) {
+  if (initialValue.currency.code !== finalValue.currency.code) {
+    throw new CurrencyMismatchError(
+      initialValue.currency.code,
+      finalValue.currency.code
+    );
+  }
+  const gain = finalValue.subtract(initialValue);
+  return Number(gain.minor) / Number(initialValue.minor);
+}
 function npv(discountRate, cashFlows) {
   if (cashFlows.length === 0) {
     throw new Error("At least one cash flow required");
@@ -1656,6 +1738,18 @@ function irr(cashFlows, guess = 0.1) {
   }
   throw new Error("IRR calculation did not converge");
 }
+function currentYield(annualCoupon, currentPrice) {
+  if (annualCoupon.currency.code !== currentPrice.currency.code) {
+    throw new CurrencyMismatchError(
+      annualCoupon.currency.code,
+      currentPrice.currency.code
+    );
+  }
+  if (currentPrice.minor <= 0n) {
+    throw new InvalidArgumentError("Current price must be positive");
+  }
+  return Number(annualCoupon.minor) / Number(currentPrice.minor);
+}
 
 // src/financial/rate.ts
 var _Rate = class _Rate {
@@ -1861,11 +1955,124 @@ var _Rate = class _Rate {
 _Rate.SCALE = 10n ** 18n;
 var Rate = _Rate;
 
+// src/financial/simple.ts
+function simpleInterest(principal, options) {
+  const { rate, years, rounding = "HALF_EVEN" /* HALF_EVEN */ } = options;
+  if (rate.isZero() || years === 0) {
+    return Money.zero(principal.currency);
+  }
+  const interestMultiplier = rate.toDecimal() * years;
+  return principal.multiply(interestMultiplier, { rounding });
+}
+function simpleInterestTotal(principal, options) {
+  const { rate, years, rounding = "HALF_EVEN" /* HALF_EVEN */ } = options;
+  if (rate.isZero() || years === 0) {
+    return principal;
+  }
+  const totalMultiplier = 1 + rate.toDecimal() * years;
+  return principal.multiply(totalMultiplier, { rounding });
+}
+
+// src/financial/leverage.ts
+function debtToEquity(totalDebt, totalEquity) {
+  assertSameCurrency(totalDebt, totalEquity);
+  if (totalEquity.isZero()) {
+    throw new Error("Total equity cannot be zero");
+  }
+  return Number(totalDebt.minor) / Number(totalEquity.minor);
+}
+function debtToAssets(totalDebt, totalAssets) {
+  assertSameCurrency(totalDebt, totalAssets);
+  if (totalAssets.isZero()) {
+    throw new Error("Total assets cannot be zero");
+  }
+  return Number(totalDebt.minor) / Number(totalAssets.minor);
+}
+function interestCoverage(ebit, interestExpense) {
+  assertSameCurrency(ebit, interestExpense);
+  if (interestExpense.isZero()) {
+    return Infinity;
+  }
+  return Number(ebit.minor) / Number(interestExpense.minor);
+}
+function equityMultiplier(totalAssets, totalEquity) {
+  assertSameCurrency(totalAssets, totalEquity);
+  if (totalEquity.isZero()) {
+    throw new Error("Total equity cannot be zero");
+  }
+  return Number(totalAssets.minor) / Number(totalEquity.minor);
+}
+function leverageRatios(inputs) {
+  return {
+    debtToEquity: debtToEquity(inputs.totalDebt, inputs.totalEquity),
+    debtToAssets: debtToAssets(inputs.totalDebt, inputs.totalAssets),
+    interestCoverage: interestCoverage(inputs.ebit, inputs.interestExpense),
+    equityMultiplier: equityMultiplier(inputs.totalAssets, inputs.totalEquity)
+  };
+}
+
+// src/financial/depreciation.ts
+function straightLineDepreciation(options) {
+  const {
+    cost,
+    salvageValue,
+    usefulLife,
+    rounding = "HALF_EVEN" /* HALF_EVEN */
+  } = options;
+  if (cost.currency.code !== salvageValue.currency.code) {
+    throw new CurrencyMismatchError(
+      cost.currency.code,
+      salvageValue.currency.code
+    );
+  }
+  if (usefulLife <= 0) {
+    throw new InvalidArgumentError("Useful life must be positive");
+  }
+  if (salvageValue.greaterThan(cost)) {
+    throw new InvalidArgumentError("Salvage value cannot be greater than cost");
+  }
+  const depreciableAmount = cost.subtract(salvageValue);
+  const annualDepreciation = depreciableAmount.divide(usefulLife, { rounding });
+  const result = {
+    annualDepreciation,
+    bookValueAtYear(year) {
+      if (year < 0) {
+        throw new InvalidArgumentError("Year must be non-negative");
+      }
+      if (year === 0) return cost;
+      const totalDepreciation = annualDepreciation.multiply(year);
+      const bookValue = cost.subtract(totalDepreciation);
+      if (bookValue.lessThan(salvageValue)) {
+        return salvageValue;
+      }
+      return bookValue;
+    },
+    schedule() {
+      const schedule = [];
+      let previousBookValue = cost;
+      const maxYears = Math.ceil(usefulLife);
+      for (let year = 1; year <= maxYears; year++) {
+        const currentBookValue = result.bookValueAtYear(year);
+        const depreciation = previousBookValue.subtract(currentBookValue);
+        schedule.push({
+          year,
+          depreciation,
+          bookValue: currentBookValue
+        });
+        previousBookValue = currentBookValue;
+      }
+      return schedule;
+    }
+  };
+  return result;
+}
+
 // src/ledger/verification.ts
 var hashFunction = null;
 function getHashFunction() {
   if (hashFunction) return hashFunction;
-  if (typeof globalThis !== "undefined") {
+  const disableNodeCrypto = globalThis.__MONETRA_DISABLE_NODE_CRYPTO__ === true;
+  if (!disableNodeCrypto && typeof globalThis !== "undefined") {
     try {
       const nodeCrypto = require("crypto");
       if (nodeCrypto && nodeCrypto.createHash) {
@@ -2014,7 +2221,7 @@ var Ledger = class _Ledger {
     const hash = await generateHash(content);
     const entry = {
       ...content,
-      hash: typeof hash === "string" ? hash : await hash
+      hash
     };
     this.entries.push(Object.freeze(entry));
     return entry;
@@ -2098,7 +2305,7 @@ var Ledger = class _Ledger {
       balance: this.getBalance(),
       currency: this.currency,
       createdAt: /* @__PURE__ */ new Date(),
-      checksum: typeof checksum === "string" ? checksum : await checksum
+      checksum
     };
   }
   /**
@@ -2164,6 +2371,7 @@ function money(amount, currency) {
   INR,
   ISK,
   InsufficientFundsError,
+  InvalidArgumentError,
   InvalidPrecisionError,
   JOD,
   JPY,
@@ -2210,16 +2418,24 @@ function money(amount, currency) {
   assertNonNegative,
   assertSameCurrency,
   compound,
+  currentYield,
+  debtToAssets,
+  debtToEquity,
   discount,
   divideWithRounding,
+  equityMultiplier,
   format,
   futureValue,
   generateHash,
   generateHashSync,
+  getAllCurrencies,
   getCurrency,
   getMinorUnitExponent,
+  interestCoverage,
+  interestOnlyPayment,
   irr,
   isCurrencyRegistered,
+  leverageRatios,
   loan,
   money,
   npv,
@@ -2229,7 +2445,13 @@ function money(amount, currency) {
   pmt,
   presentValue,
   registerCurrency,
+  roi,
   setHashFunction,
+  simpleInterest,
+  simpleInterestTotal,
+  straightLineDepreciation,
+  totalInterest,
+  totalInterestFromSchedule,
   verifyChain,
   verifyChainSync
 });