@lucaapp/service-utils 4.3.0 → 4.4.0

package/dist/lib/money/money.d.ts

@@ -1,11 +1,16 @@
 import { Model } from 'sequelize';
 import { SupportedCurrencies } from './supportedCurrencies';
+export declare enum RoundingStrategy {
+    COMMERCIAL = "commercial",// Round half up (default)
+    ROUND_DOWN = "round_down",// Always round down
+    ROUND_UP = "round_up"
+}
 interface MoneyInterface<T extends SupportedCurrencies> {
     getAmount(): number;
-    add(addend?: Money<T>): Money<T>;
-    subtract(subtrahend?: Money<T>): Money<T>;
-    multiply(multiplier: number): Money<T>;
-    divide(divisor: number): Money<T>;
+    add(addend?: Money<T>, roundingStrategy?: RoundingStrategy): Money<T>;
+    subtract(subtrahend?: Money<T>, roundingStrategy?: RoundingStrategy): Money<T>;
+    multiply(multiplier: number, roundingStrategy?: RoundingStrategy): Money<T>;
+    divide(divisor: number, roundingStrategy?: RoundingStrategy): Money<T>;
     equalsTo(comparator: Money<T>): boolean;
     lessThan(comparator: Money<T>): boolean;
     lessThanOrEqual(comparator: Money<T>): boolean;
@@ -19,7 +24,7 @@ export declare class Money<T extends SupportedCurrencies = SupportedCurrencies>
     readonly currency: T;
     private readonly value;
     static fromAmount<T extends SupportedCurrencies>(value: number, currency: T): Money<T>;
-    static fromFloat<T extends SupportedCurrencies>(value: number, currency: T): Money<T>;
+    static fromFloat<T extends SupportedCurrencies>(value: number, currency: T, roundingStrategy?: RoundingStrategy): Money<T>;
     static zero<T extends SupportedCurrencies>(currency: T): Money<T>;
     static min<T extends SupportedCurrencies>(value1: Money<T>, value2: Money<T>): Money<T>;
     static max<T extends SupportedCurrencies>(value1: Money<T>, value2: Money<T>): Money<T>;
@@ -31,9 +36,9 @@ export declare class Money<T extends SupportedCurrencies = SupportedCurrencies>
     private assertSameCurrency;
     add(addend?: Money<T>): Money<T>;
     subtract(subtrahend?: Money<T>): Money<T>;
-    multiply(multiplier: number): Money<T>;
-    divide(divisor: number): Money<T>;
-    percentage(percentage: number): Money<T>;
+    multiply(multiplier: number, roundingStrategy?: RoundingStrategy): Money<T>;
+    divide(divisor: number, roundingStrategy?: RoundingStrategy): Money<T>;
+    percentage(percentage: number, roundingStrategy?: RoundingStrategy): Money<T>;
     equalsTo(comparator: Money<T>): boolean;
     lessThan(comparator: Money<T>): boolean;
     lessThanOrEqual(comparator: Money<T>): boolean;

package/dist/lib/money/money.js

@@ -1,14 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.moneyfiedSet = exports.moneyfiedGet = exports.Money = void 0;
+exports.moneyfiedSet = exports.moneyfiedGet = exports.Money = exports.RoundingStrategy = void 0;
 const supportedCurrencies_1 = require("./supportedCurrencies");
+var RoundingStrategy;
+(function (RoundingStrategy) {
+    RoundingStrategy["COMMERCIAL"] = "commercial";
+    RoundingStrategy["ROUND_DOWN"] = "round_down";
+    RoundingStrategy["ROUND_UP"] = "round_up";
+})(RoundingStrategy || (exports.RoundingStrategy = RoundingStrategy = {}));
 const MINOR_UNITS_PER_MAJOR_UNIT = 100;
 const EPSILON = 0.00000000001;
 const roundHalfUp = (value) => {
     const rounded = Math.sign(value) * Math.round(Math.abs(value) + EPSILON);
     return rounded === 0 ? 0 : rounded;
 };
-const convertToMinorUnits = (amountInMajorUnits) => roundHalfUp(amountInMajorUnits * MINOR_UNITS_PER_MAJOR_UNIT);
+const roundDown = (value) => {
+    const truncated = Math.trunc(value);
+    return truncated === 0 ? 0 : truncated;
+};
+const roundUp = (value) => {
+    if (value >= 0) {
+        const ceiled = Math.ceil(value);
+        return ceiled === 0 ? 0 : ceiled;
+    }
+    else {
+        // For negative numbers, "round up" means towards zero (less negative)
+        const floored = Math.floor(value);
+        return floored === 0 ? 0 : floored;
+    }
+};
+const applyRounding = (value, strategy = RoundingStrategy.COMMERCIAL) => {
+    switch (strategy) {
+        case RoundingStrategy.COMMERCIAL:
+            return roundHalfUp(value);
+        case RoundingStrategy.ROUND_DOWN:
+            return roundDown(value);
+        case RoundingStrategy.ROUND_UP:
+            return roundUp(value);
+        default:
+            return roundHalfUp(value);
+    }
+};
+const convertToMinorUnits = (amountInMajorUnits, roundingStrategy = RoundingStrategy.COMMERCIAL) => applyRounding(amountInMajorUnits * MINOR_UNITS_PER_MAJOR_UNIT, roundingStrategy);
 const convertToMajorUnits = (amountInMinorUnits) => amountInMinorUnits / MINOR_UNITS_PER_MAJOR_UNIT;
 class Money {
     static fromAmount(value, currency) {
@@ -17,8 +50,8 @@ class Money {
         }
         return new Money(value, currency);
     }
-    static fromFloat(value, currency) {
-        return new Money(convertToMinorUnits(value), currency);
+    static fromFloat(value, currency, roundingStrategy = RoundingStrategy.COMMERCIAL) {
+        return new Money(convertToMinorUnits(value, roundingStrategy), currency);
     }
     static zero(currency) {
         return Money.fromAmount(0, currency);
@@ -81,20 +114,20 @@ class Money {
         this.assertSameCurrency(subtrahend);
         return Money.fromAmount(this.value - (subtrahend?.value || 0), this.currency);
     }
-    multiply(multiplier) {
-        return Money.fromAmount(roundHalfUp(this.value * multiplier), this.currency);
+    multiply(multiplier, roundingStrategy = RoundingStrategy.COMMERCIAL) {
+        return Money.fromAmount(applyRounding(this.value * multiplier, roundingStrategy), this.currency);
     }
-    divide(divisor) {
+    divide(divisor, roundingStrategy = RoundingStrategy.COMMERCIAL) {
         if (divisor === 0) {
             throw new TypeError('Divisor cannot be zero');
         }
-        return Money.fromAmount(roundHalfUp(this.value / divisor), this.currency);
+        return Money.fromAmount(applyRounding(this.value / divisor, roundingStrategy), this.currency);
     }
-    percentage(percentage) {
+    percentage(percentage, roundingStrategy = RoundingStrategy.COMMERCIAL) {
         if (Number.isNaN(percentage) || percentage < 0 || percentage > 100) {
             throw new TypeError('Expected number between 0 and 100');
         }
-        return Money.fromAmount(roundHalfUp((this.value / 100) * percentage), this.currency);
+        return Money.fromAmount(applyRounding((this.value / 100) * percentage, roundingStrategy), this.currency);
     }
     equalsTo(comparator) {
         this.assertSameCurrency(comparator);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lucaapp/service-utils",
-  "version": "4.3.0",
+  "version": "4.4.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [