@fin.cx/einvoice 5.0.2 → 5.1.2

package/dist_ts/formats/utils/currency.calculator.decimal.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Currency Calculator using Decimal Arithmetic
+ * EN16931-compliant monetary calculations with exact precision
+ */
+import { Decimal, RoundingMode } from './decimal.js';
+import type { TCurrency } from '@tsclass/tsclass/dist_ts/finance/index.js';
+/**
+ * Currency-aware calculator using decimal arithmetic for EN16931 compliance
+ */
+export declare class DecimalCurrencyCalculator {
+    private readonly currency;
+    private readonly minorUnits;
+    private readonly roundingMode;
+    constructor(currency: TCurrency, roundingMode?: RoundingMode);
+    /**
+     * Round a decimal value according to currency rules
+     */
+    round(value: Decimal | number | string): Decimal;
+    /**
+     * Calculate line net amount: (quantity × unitPrice) - discount
+     */
+    calculateLineNet(quantity: Decimal | number | string, unitPrice: Decimal | number | string, discount?: Decimal | number | string): Decimal;
+    /**
+     * Calculate VAT amount from base and rate
+     */
+    calculateVAT(baseAmount: Decimal | number | string, vatRate: Decimal | number | string): Decimal;
+    /**
+     * Calculate total with VAT
+     */
+    calculateGrossAmount(netAmount: Decimal | number | string, vatAmount: Decimal | number | string): Decimal;
+    /**
+     * Calculate sum of line items
+     */
+    sumLineItems(items: Array<{
+        quantity: Decimal | number | string;
+        unitPrice: Decimal | number | string;
+        discount?: Decimal | number | string;
+    }>): Decimal;
+    /**
+     * Calculate VAT breakdown by rate
+     */
+    calculateVATBreakdown(items: Array<{
+        netAmount: Decimal | number | string;
+        vatRate: Decimal | number | string;
+    }>): Array<{
+        rate: Decimal;
+        baseAmount: Decimal;
+        vatAmount: Decimal;
+    }>;
+    /**
+     * Check if two amounts are equal within currency precision
+     */
+    areEqual(amount1: Decimal | number | string, amount2: Decimal | number | string): boolean;
+    /**
+     * Calculate payment terms discount
+     */
+    calculatePaymentDiscount(amount: Decimal | number | string, discountRate: Decimal | number | string): Decimal;
+    /**
+     * Distribute a total amount across items proportionally
+     */
+    distributeAmount(totalToDistribute: Decimal | number | string, items: Array<{
+        value: Decimal | number | string;
+    }>): Decimal[];
+    /**
+     * Calculate compound amount (e.g., for multiple charges/allowances)
+     */
+    calculateCompoundAmount(baseAmount: Decimal | number | string, adjustments: Array<{
+        type: 'charge' | 'allowance';
+        value: Decimal | number | string;
+        isPercentage?: boolean;
+    }>): Decimal;
+    /**
+     * Validate monetary calculation according to EN16931 rules
+     */
+    validateCalculation(expected: Decimal | number | string, calculated: Decimal | number | string, ruleName: string): {
+        valid: boolean;
+        expected: string;
+        calculated: string;
+        difference?: string;
+        rule: string;
+    };
+    /**
+     * Format amount for display
+     */
+    formatAmount(amount: Decimal | number | string): string;
+    /**
+     * Get currency information
+     */
+    getCurrencyInfo(): {
+        code: TCurrency;
+        minorUnits: number;
+        roundingMode: RoundingMode;
+    };
+}
+/**
+ * Factory function to create a decimal currency calculator
+ */
+export declare function createDecimalCalculator(currency: TCurrency, roundingMode?: RoundingMode): DecimalCurrencyCalculator;

package/dist_ts/formats/utils/currency.calculator.decimal.js

@@ -0,0 +1,212 @@
+/**
+ * Currency Calculator using Decimal Arithmetic
+ * EN16931-compliant monetary calculations with exact precision
+ */
+import { Decimal, decimal, RoundingMode } from './decimal.js';
+import { getCurrencyMinorUnits } from './currency.utils.js';
+/**
+ * Currency-aware calculator using decimal arithmetic for EN16931 compliance
+ */
+export class DecimalCurrencyCalculator {
+    constructor(currency, roundingMode = 'HALF_UP') {
+        this.currency = currency;
+        this.minorUnits = getCurrencyMinorUnits(currency);
+        this.roundingMode = roundingMode;
+    }
+    /**
+     * Round a decimal value according to currency rules
+     */
+    round(value) {
+        const decimalValue = value instanceof Decimal ? value : new Decimal(value);
+        return decimalValue.round(this.minorUnits, this.roundingMode);
+    }
+    /**
+     * Calculate line net amount: (quantity × unitPrice) - discount
+     */
+    calculateLineNet(quantity, unitPrice, discount = '0') {
+        const qty = quantity instanceof Decimal ? quantity : new Decimal(quantity);
+        const price = unitPrice instanceof Decimal ? unitPrice : new Decimal(unitPrice);
+        const disc = discount instanceof Decimal ? discount : new Decimal(discount);
+        const gross = qty.multiply(price);
+        const net = gross.subtract(disc);
+        return this.round(net);
+    }
+    /**
+     * Calculate VAT amount from base and rate
+     */
+    calculateVAT(baseAmount, vatRate) {
+        const base = baseAmount instanceof Decimal ? baseAmount : new Decimal(baseAmount);
+        const rate = vatRate instanceof Decimal ? vatRate : new Decimal(vatRate);
+        const vat = base.percentage(rate);
+        return this.round(vat);
+    }
+    /**
+     * Calculate total with VAT
+     */
+    calculateGrossAmount(netAmount, vatAmount) {
+        const net = netAmount instanceof Decimal ? netAmount : new Decimal(netAmount);
+        const vat = vatAmount instanceof Decimal ? vatAmount : new Decimal(vatAmount);
+        return this.round(net.add(vat));
+    }
+    /**
+     * Calculate sum of line items
+     */
+    sumLineItems(items) {
+        let total = Decimal.ZERO;
+        for (const item of items) {
+            const lineNet = this.calculateLineNet(item.quantity, item.unitPrice, item.discount);
+            total = total.add(lineNet);
+        }
+        return this.round(total);
+    }
+    /**
+     * Calculate VAT breakdown by rate
+     */
+    calculateVATBreakdown(items) {
+        // Group by VAT rate
+        const groups = new Map();
+        for (const item of items) {
+            const net = item.netAmount instanceof Decimal ? item.netAmount : new Decimal(item.netAmount);
+            const rate = item.vatRate instanceof Decimal ? item.vatRate : new Decimal(item.vatRate);
+            const rateKey = rate.toString();
+            if (groups.has(rateKey)) {
+                const group = groups.get(rateKey);
+                group.baseAmount = group.baseAmount.add(net);
+            }
+            else {
+                groups.set(rateKey, {
+                    rate,
+                    baseAmount: net
+                });
+            }
+        }
+        // Calculate VAT for each group
+        const breakdown = [];
+        for (const group of groups.values()) {
+            breakdown.push({
+                rate: group.rate,
+                baseAmount: this.round(group.baseAmount),
+                vatAmount: this.calculateVAT(group.baseAmount, group.rate)
+            });
+        }
+        return breakdown;
+    }
+    /**
+     * Check if two amounts are equal within currency precision
+     */
+    areEqual(amount1, amount2) {
+        const a1 = amount1 instanceof Decimal ? amount1 : new Decimal(amount1);
+        const a2 = amount2 instanceof Decimal ? amount2 : new Decimal(amount2);
+        // Round both to currency precision before comparing
+        const rounded1 = this.round(a1);
+        const rounded2 = this.round(a2);
+        return rounded1.equals(rounded2);
+    }
+    /**
+     * Calculate payment terms discount
+     */
+    calculatePaymentDiscount(amount, discountRate) {
+        const amt = amount instanceof Decimal ? amount : new Decimal(amount);
+        const rate = discountRate instanceof Decimal ? discountRate : new Decimal(discountRate);
+        const discount = amt.percentage(rate);
+        return this.round(discount);
+    }
+    /**
+     * Distribute a total amount across items proportionally
+     */
+    distributeAmount(totalToDistribute, items) {
+        const total = totalToDistribute instanceof Decimal ? totalToDistribute : new Decimal(totalToDistribute);
+        // Calculate sum of all item values
+        const itemSum = items.reduce((sum, item) => {
+            const value = item.value instanceof Decimal ? item.value : new Decimal(item.value);
+            return sum.add(value);
+        }, Decimal.ZERO);
+        if (itemSum.isZero()) {
+            // Can't distribute if sum is zero
+            return items.map(() => Decimal.ZERO);
+        }
+        const distributed = [];
+        let distributedSum = Decimal.ZERO;
+        // Distribute proportionally
+        for (let i = 0; i < items.length; i++) {
+            const itemValue = items[i].value instanceof Decimal ? items[i].value : new Decimal(items[i].value);
+            if (i === items.length - 1) {
+                // Last item gets the remainder to avoid rounding errors
+                distributed.push(total.subtract(distributedSum));
+            }
+            else {
+                const itemDecimal = itemValue instanceof Decimal ? itemValue : new Decimal(itemValue);
+                const proportion = itemDecimal.divide(itemSum);
+                const distributedAmount = this.round(total.multiply(proportion));
+                distributed.push(distributedAmount);
+                distributedSum = distributedSum.add(distributedAmount);
+            }
+        }
+        return distributed;
+    }
+    /**
+     * Calculate compound amount (e.g., for multiple charges/allowances)
+     */
+    calculateCompoundAmount(baseAmount, adjustments) {
+        let result = baseAmount instanceof Decimal ? baseAmount : new Decimal(baseAmount);
+        for (const adjustment of adjustments) {
+            const value = adjustment.value instanceof Decimal ? adjustment.value : new Decimal(adjustment.value);
+            let adjustmentAmount;
+            if (adjustment.isPercentage) {
+                adjustmentAmount = result.percentage(value);
+            }
+            else {
+                adjustmentAmount = value;
+            }
+            if (adjustment.type === 'charge') {
+                result = result.add(adjustmentAmount);
+            }
+            else {
+                result = result.subtract(adjustmentAmount);
+            }
+        }
+        return this.round(result);
+    }
+    /**
+     * Validate monetary calculation according to EN16931 rules
+     */
+    validateCalculation(expected, calculated, ruleName) {
+        const exp = expected instanceof Decimal ? expected : new Decimal(expected);
+        const calc = calculated instanceof Decimal ? calculated : new Decimal(calculated);
+        const roundedExp = this.round(exp);
+        const roundedCalc = this.round(calc);
+        const valid = roundedExp.equals(roundedCalc);
+        return {
+            valid,
+            expected: roundedExp.toFixed(this.minorUnits),
+            calculated: roundedCalc.toFixed(this.minorUnits),
+            difference: valid ? undefined : roundedExp.subtract(roundedCalc).abs().toFixed(this.minorUnits),
+            rule: ruleName
+        };
+    }
+    /**
+     * Format amount for display
+     */
+    formatAmount(amount) {
+        const amt = amount instanceof Decimal ? amount : new Decimal(amount);
+        const rounded = this.round(amt);
+        return `${rounded.toFixed(this.minorUnits)} ${this.currency}`;
+    }
+    /**
+     * Get currency information
+     */
+    getCurrencyInfo() {
+        return {
+            code: this.currency,
+            minorUnits: this.minorUnits,
+            roundingMode: this.roundingMode
+        };
+    }
+}
+/**
+ * Factory function to create a decimal currency calculator
+ */
+export function createDecimalCalculator(currency, roundingMode) {
+    return new DecimalCurrencyCalculator(currency, roundingMode);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"currency.calculator.decimal.js","sourceRoot":"","sources":["../../../ts/formats/utils/currency.calculator.decimal.ts"],"names":[],"mappings":"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"}

package/dist_ts/formats/utils/currency.utils.d.ts

@@ -0,0 +1,99 @@
+/**
+ * ISO 4217 Currency utilities for EN16931 compliance
+ * Provides currency-aware rounding and decimal handling
+ */
+/**
+ * ISO 4217 Currency minor units (decimal places)
+ * Based on ISO 4217:2015 standard
+ *
+ * Most currencies use 2 decimal places, but there are exceptions:
+ * - 0 decimals: JPY, KRW, CLP, etc.
+ * - 3 decimals: BHD, IQD, JOD, KWD, OMR, TND
+ * - 4 decimals: CLF (Chilean Unit of Account)
+ */
+export declare const ISO4217MinorUnits: Record<string, number>;
+/**
+ * Rounding modes for currency calculations
+ */
+export declare enum RoundingMode {
+    HALF_UP = "HALF_UP",// Round half values up (0.5 → 1, -0.5 → -1)
+    HALF_DOWN = "HALF_DOWN",// Round half values down (0.5 → 0, -0.5 → 0)
+    HALF_EVEN = "HALF_EVEN",// Banker's rounding (0.5 → 0, 1.5 → 2)
+    UP = "UP",// Always round up
+    DOWN = "DOWN",// Always round down (truncate)
+    CEILING = "CEILING",// Round toward positive infinity
+    FLOOR = "FLOOR"
+}
+/**
+ * Currency configuration for calculations
+ */
+export interface CurrencyConfig {
+    code: string;
+    minorUnits: number;
+    roundingMode: RoundingMode;
+    tolerance?: number;
+}
+/**
+ * Get minor units (decimal places) for a currency
+ */
+export declare function getCurrencyMinorUnits(currencyCode: string): number;
+/**
+ * Round a value according to currency rules
+ */
+export declare function roundToCurrency(value: number, currencyCode: string, mode?: RoundingMode): number;
+/**
+ * Get tolerance for currency comparison
+ * Based on the smallest representable unit for the currency
+ */
+export declare function getCurrencyTolerance(currencyCode: string): number;
+/**
+ * Compare two monetary values with currency-aware tolerance
+ */
+export declare function areMonetaryValuesEqual(value1: number, value2: number, currencyCode: string): boolean;
+/**
+ * Format a value according to currency decimal places
+ */
+export declare function formatCurrencyValue(value: number, currencyCode: string): string;
+/**
+ * Validate if a value has correct decimal places for a currency
+ */
+export declare function hasValidDecimalPlaces(value: number, currencyCode: string): boolean;
+/**
+ * Currency calculation context for EN16931 compliance
+ */
+export declare class CurrencyCalculator {
+    private currency;
+    private minorUnits;
+    private roundingMode;
+    constructor(config: CurrencyConfig | string);
+    /**
+     * Round a value according to configured rules
+     */
+    round(value: number): number;
+    /**
+     * Calculate line net amount with rounding
+     * EN16931: Line net = (quantity × unit price) - line discounts
+     */
+    calculateLineNet(quantity: number, unitPrice: number, discount?: number): number;
+    /**
+     * Calculate VAT amount with rounding
+     * EN16931: VAT amount = taxable amount × (rate / 100)
+     */
+    calculateVAT(taxableAmount: number, rate: number): number;
+    /**
+     * Compare values with currency-aware tolerance
+     */
+    areEqual(value1: number, value2: number): boolean;
+    /**
+     * Get the tolerance for comparisons
+     */
+    getTolerance(): number;
+    /**
+     * Format value for display
+     */
+    format(value: number): string;
+}
+/**
+ * Get version info for ISO 4217 data
+ */
+export declare function getISO4217Version(): string;