@fin.cx/einvoice 5.0.2 → 5.1.2

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

@@ -0,0 +1,250 @@
+/**
+ * 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 const ISO4217MinorUnits = {
+    // Major currencies
+    'EUR': 2, // Euro
+    'USD': 2, // US Dollar
+    'GBP': 2, // British Pound
+    'CHF': 2, // Swiss Franc
+    'CAD': 2, // Canadian Dollar
+    'AUD': 2, // Australian Dollar
+    'NZD': 2, // New Zealand Dollar
+    'CNY': 2, // Chinese Yuan
+    'INR': 2, // Indian Rupee
+    'MXN': 2, // Mexican Peso
+    'BRL': 2, // Brazilian Real
+    'RUB': 2, // Russian Ruble
+    'ZAR': 2, // South African Rand
+    'SGD': 2, // Singapore Dollar
+    'HKD': 2, // Hong Kong Dollar
+    'NOK': 2, // Norwegian Krone
+    'SEK': 2, // Swedish Krona
+    'DKK': 2, // Danish Krone
+    'PLN': 2, // Polish Zloty
+    'CZK': 2, // Czech Koruna
+    'HUF': 2, // Hungarian Forint (technically 2, though often shown as 0)
+    'RON': 2, // Romanian Leu
+    'BGN': 2, // Bulgarian Lev
+    'HRK': 2, // Croatian Kuna
+    'TRY': 2, // Turkish Lira
+    'ISK': 0, // Icelandic Króna (0 decimals)
+    // Zero decimal currencies
+    'JPY': 0, // Japanese Yen
+    'KRW': 0, // South Korean Won
+    'CLP': 0, // Chilean Peso
+    'PYG': 0, // Paraguayan Guaraní
+    'RWF': 0, // Rwandan Franc
+    'VND': 0, // Vietnamese Dong
+    'XAF': 0, // CFA Franc BEAC
+    'XOF': 0, // CFA Franc BCEAO
+    'XPF': 0, // CFP Franc
+    'BIF': 0, // Burundian Franc
+    'DJF': 0, // Djiboutian Franc
+    'GNF': 0, // Guinean Franc
+    'KMF': 0, // Comorian Franc
+    'MGA': 0, // Malagasy Ariary
+    'UGX': 0, // Ugandan Shilling
+    'VUV': 0, // Vanuatu Vatu
+    // Three decimal currencies
+    'BHD': 3, // Bahraini Dinar
+    'IQD': 3, // Iraqi Dinar
+    'JOD': 3, // Jordanian Dinar
+    'KWD': 3, // Kuwaiti Dinar
+    'LYD': 3, // Libyan Dinar
+    'OMR': 3, // Omani Rial
+    'TND': 3, // Tunisian Dinar
+    // Four decimal currencies
+    'CLF': 4, // Chilean Unit of Account (UF)
+    'UYW': 4, // Unidad Previsional (Uruguay)
+};
+/**
+ * Rounding modes for currency calculations
+ */
+export var RoundingMode;
+(function (RoundingMode) {
+    RoundingMode["HALF_UP"] = "HALF_UP";
+    RoundingMode["HALF_DOWN"] = "HALF_DOWN";
+    RoundingMode["HALF_EVEN"] = "HALF_EVEN";
+    RoundingMode["UP"] = "UP";
+    RoundingMode["DOWN"] = "DOWN";
+    RoundingMode["CEILING"] = "CEILING";
+    RoundingMode["FLOOR"] = "FLOOR"; // Round toward negative infinity
+})(RoundingMode || (RoundingMode = {}));
+/**
+ * Get minor units (decimal places) for a currency
+ */
+export function getCurrencyMinorUnits(currencyCode) {
+    const code = currencyCode.toUpperCase();
+    return ISO4217MinorUnits[code] ?? 2; // Default to 2 if unknown
+}
+/**
+ * Round a value according to currency rules
+ */
+export function roundToCurrency(value, currencyCode, mode = RoundingMode.HALF_UP) {
+    const minorUnits = getCurrencyMinorUnits(currencyCode);
+    if (minorUnits === 0) {
+        // For zero decimal currencies, round to integer
+        return Math.round(value);
+    }
+    const multiplier = Math.pow(10, minorUnits);
+    const scaled = value * multiplier;
+    let rounded;
+    switch (mode) {
+        case RoundingMode.HALF_UP:
+            // Round half values away from zero
+            if (scaled >= 0) {
+                rounded = Math.floor(scaled + 0.5);
+            }
+            else {
+                rounded = Math.ceil(scaled - 0.5);
+            }
+            break;
+        case RoundingMode.HALF_DOWN:
+            // Round half values toward zero
+            const fraction = Math.abs(scaled % 1);
+            if (fraction === 0.5) {
+                // Exactly 0.5 - round toward zero
+                rounded = scaled >= 0 ? Math.floor(scaled) : Math.ceil(scaled);
+            }
+            else {
+                // Not exactly 0.5 - use normal rounding
+                rounded = Math.round(scaled);
+            }
+            break;
+        case RoundingMode.HALF_EVEN:
+            // Banker's rounding
+            const isHalf = Math.abs(scaled % 1) === 0.5;
+            if (isHalf) {
+                const floor = Math.floor(scaled);
+                rounded = floor % 2 === 0 ? floor : Math.ceil(scaled);
+            }
+            else {
+                rounded = Math.round(scaled);
+            }
+            break;
+        case RoundingMode.UP:
+            rounded = scaled >= 0 ? Math.ceil(scaled) : Math.floor(scaled);
+            break;
+        case RoundingMode.DOWN:
+            rounded = Math.trunc(scaled);
+            break;
+        case RoundingMode.CEILING:
+            rounded = Math.ceil(scaled);
+            break;
+        case RoundingMode.FLOOR:
+            rounded = Math.floor(scaled);
+            break;
+        default:
+            rounded = Math.round(scaled);
+    }
+    return rounded / multiplier;
+}
+/**
+ * Get tolerance for currency comparison
+ * Based on the smallest representable unit for the currency
+ */
+export function getCurrencyTolerance(currencyCode) {
+    const minorUnits = getCurrencyMinorUnits(currencyCode);
+    // Tolerance is half of the smallest unit
+    return 0.5 * Math.pow(10, -minorUnits);
+}
+/**
+ * Compare two monetary values with currency-aware tolerance
+ */
+export function areMonetaryValuesEqual(value1, value2, currencyCode) {
+    const tolerance = getCurrencyTolerance(currencyCode);
+    return Math.abs(value1 - value2) <= tolerance;
+}
+/**
+ * Format a value according to currency decimal places
+ */
+export function formatCurrencyValue(value, currencyCode) {
+    const minorUnits = getCurrencyMinorUnits(currencyCode);
+    return value.toFixed(minorUnits);
+}
+/**
+ * Validate if a value has correct decimal places for a currency
+ */
+export function hasValidDecimalPlaces(value, currencyCode) {
+    const minorUnits = getCurrencyMinorUnits(currencyCode);
+    const multiplier = Math.pow(10, minorUnits);
+    const scaled = Math.round(value * multiplier);
+    const reconstructed = scaled / multiplier;
+    return Math.abs(value - reconstructed) < Number.EPSILON;
+}
+/**
+ * Currency calculation context for EN16931 compliance
+ */
+export class CurrencyCalculator {
+    constructor(config) {
+        if (typeof config === 'string') {
+            this.currency = config;
+            this.minorUnits = getCurrencyMinorUnits(config);
+            this.roundingMode = RoundingMode.HALF_UP;
+        }
+        else {
+            this.currency = config.code;
+            this.minorUnits = config.minorUnits;
+            this.roundingMode = config.roundingMode;
+        }
+    }
+    /**
+     * Round a value according to configured rules
+     */
+    round(value) {
+        return roundToCurrency(value, this.currency, this.roundingMode);
+    }
+    /**
+     * Calculate line net amount with rounding
+     * EN16931: Line net = (quantity × unit price) - line discounts
+     */
+    calculateLineNet(quantity, unitPrice, discount = 0) {
+        const gross = quantity * unitPrice;
+        const net = gross - discount;
+        return this.round(net);
+    }
+    /**
+     * Calculate VAT amount with rounding
+     * EN16931: VAT amount = taxable amount × (rate / 100)
+     */
+    calculateVAT(taxableAmount, rate) {
+        const vat = taxableAmount * (rate / 100);
+        return this.round(vat);
+    }
+    /**
+     * Compare values with currency-aware tolerance
+     */
+    areEqual(value1, value2) {
+        return areMonetaryValuesEqual(value1, value2, this.currency);
+    }
+    /**
+     * Get the tolerance for comparisons
+     */
+    getTolerance() {
+        return getCurrencyTolerance(this.currency);
+    }
+    /**
+     * Format value for display
+     */
+    format(value) {
+        return formatCurrencyValue(value, this.currency);
+    }
+}
+/**
+ * Get version info for ISO 4217 data
+ */
+export function getISO4217Version() {
+    return '2015'; // Update when currency list is updated
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"currency.utils.js","sourceRoot":"","sources":["../../../ts/formats/utils/currency.utils.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,151 @@
+/**
+ * Decimal Arithmetic Library for EN16931 Compliance
+ * Provides arbitrary precision decimal arithmetic to avoid floating-point errors
+ *
+ * Based on EN16931 requirements for financial calculations:
+ * - All monetary amounts must be calculated with sufficient precision
+ * - Rounding must be consistent and predictable
+ * - No loss of precision in intermediate calculations
+ */
+/**
+ * Decimal class for arbitrary precision arithmetic
+ * Internally stores the value as an integer with a scale factor
+ */
+export declare class Decimal {
+    private readonly value;
+    private readonly scale;
+    private static _ZERO;
+    private static _ONE;
+    private static _TEN;
+    private static _HUNDRED;
+    static get ZERO(): Decimal;
+    static get ONE(): Decimal;
+    static get TEN(): Decimal;
+    static get HUNDRED(): Decimal;
+    private static readonly DEFAULT_SCALE;
+    /**
+     * Create a new Decimal from various input types
+     */
+    constructor(value: string | number | bigint | Decimal, scale?: number);
+    /**
+     * Convert to string representation
+     */
+    toString(decimalPlaces?: number): string;
+    /**
+     * Convert to number (may lose precision)
+     */
+    toNumber(): number;
+    /**
+     * Convert to fixed decimal places string
+     */
+    toFixed(decimalPlaces: number): string;
+    /**
+     * Add two decimals
+     */
+    add(other: Decimal | number | string): Decimal;
+    /**
+     * Subtract another decimal
+     */
+    subtract(other: Decimal | number | string): Decimal;
+    /**
+     * Multiply by another decimal
+     */
+    multiply(other: Decimal | number | string): Decimal;
+    /**
+     * Divide by another decimal
+     */
+    divide(other: Decimal | number | string, precision?: number): Decimal;
+    /**
+     * Calculate percentage (this * rate / 100)
+     */
+    percentage(rate: Decimal | number | string): Decimal;
+    /**
+     * Round to specified decimal places using a specific rounding mode
+     */
+    round(decimalPlaces: number, mode?: 'HALF_UP' | 'HALF_DOWN' | 'HALF_EVEN' | 'UP' | 'DOWN' | 'CEILING' | 'FLOOR'): Decimal;
+    /**
+     * Compare with another decimal
+     */
+    compareTo(other: Decimal | number | string): number;
+    /**
+     * Check equality
+     */
+    equals(other: Decimal | number | string, tolerance?: Decimal | number | string): boolean;
+    /**
+     * Check if less than
+     */
+    lessThan(other: Decimal | number | string): boolean;
+    /**
+     * Check if less than or equal
+     */
+    lessThanOrEqual(other: Decimal | number | string): boolean;
+    /**
+     * Check if greater than
+     */
+    greaterThan(other: Decimal | number | string): boolean;
+    /**
+     * Check if greater than or equal
+     */
+    greaterThanOrEqual(other: Decimal | number | string): boolean;
+    /**
+     * Get absolute value
+     */
+    abs(): Decimal;
+    /**
+     * Negate the value
+     */
+    negate(): Decimal;
+    /**
+     * Check if zero
+     */
+    isZero(): boolean;
+    /**
+     * Check if negative
+     */
+    isNegative(): boolean;
+    /**
+     * Check if positive
+     */
+    isPositive(): boolean;
+    /**
+     * Rescale to a different number of decimal places
+     */
+    private rescale;
+    /**
+     * Normalize by removing trailing zeros
+     */
+    private normalize;
+    /**
+     * Create a Decimal from a percentage string (e.g., "19%" -> 0.19)
+     */
+    static fromPercentage(value: string): Decimal;
+    /**
+     * Sum an array of decimals
+     */
+    static sum(values: (Decimal | number | string)[]): Decimal;
+    /**
+     * Get the minimum value
+     */
+    static min(...values: (Decimal | number | string)[]): Decimal;
+    /**
+     * Get the maximum value
+     */
+    static max(...values: (Decimal | number | string)[]): Decimal;
+}
+/**
+ * Helper function to create a Decimal
+ */
+export declare function decimal(value: string | number | bigint | Decimal): Decimal;
+/**
+ * Export commonly used rounding modes
+ */
+export declare const RoundingMode: {
+    readonly HALF_UP: "HALF_UP";
+    readonly HALF_DOWN: "HALF_DOWN";
+    readonly HALF_EVEN: "HALF_EVEN";
+    readonly UP: "UP";
+    readonly DOWN: "DOWN";
+    readonly CEILING: "CEILING";
+    readonly FLOOR: "FLOOR";
+};
+export type RoundingMode = typeof RoundingMode[keyof typeof RoundingMode];