@fin.cx/einvoice 5.0.2 → 5.1.2

package/dist_ts/formats/utils/decimal.js

@@ -0,0 +1,435 @@
+/**
+ * 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 class Decimal {
+    static get ZERO() {
+        if (!this._ZERO)
+            this._ZERO = new Decimal(0);
+        return this._ZERO;
+    }
+    static get ONE() {
+        if (!this._ONE)
+            this._ONE = new Decimal(1);
+        return this._ONE;
+    }
+    static get TEN() {
+        if (!this._TEN)
+            this._TEN = new Decimal(10);
+        return this._TEN;
+    }
+    static get HUNDRED() {
+        if (!this._HUNDRED)
+            this._HUNDRED = new Decimal(100);
+        return this._HUNDRED;
+    }
+    // Default scale for monetary calculations (4 decimal places for intermediate calculations)
+    static { this.DEFAULT_SCALE = 4; }
+    /**
+     * Create a new Decimal from various input types
+     */
+    constructor(value, scale) {
+        if (value instanceof Decimal) {
+            this.value = value.value;
+            this.scale = value.scale;
+            return;
+        }
+        // Special handling for direct bigint with scale (internal use)
+        if (typeof value === 'bigint' && scale !== undefined) {
+            this.value = value;
+            this.scale = scale;
+            return;
+        }
+        // Determine scale if not provided
+        if (scale === undefined) {
+            if (typeof value === 'string') {
+                const parts = value.split('.');
+                scale = parts.length > 1 ? parts[1].length : 0;
+            }
+            else {
+                scale = Decimal.DEFAULT_SCALE;
+            }
+        }
+        this.scale = scale;
+        // Convert to scaled integer
+        if (typeof value === 'string') {
+            // Remove any formatting
+            value = value.replace(/[^\d.-]/g, '');
+            const parts = value.split('.');
+            const integerPart = parts[0] || '0';
+            const decimalPart = (parts[1] || '').padEnd(scale, '0').slice(0, scale);
+            this.value = BigInt(integerPart + decimalPart);
+        }
+        else if (typeof value === 'number') {
+            // Handle floating point numbers
+            if (!isFinite(value)) {
+                throw new Error(`Invalid number value: ${value}`);
+            }
+            const multiplier = Math.pow(10, scale);
+            this.value = BigInt(Math.round(value * multiplier));
+        }
+        else {
+            // bigint
+            this.value = value * BigInt(Math.pow(10, scale));
+        }
+    }
+    /**
+     * Convert to string representation
+     */
+    toString(decimalPlaces) {
+        const absValue = this.value < 0n ? -this.value : this.value;
+        const str = absValue.toString().padStart(this.scale + 1, '0');
+        const integerPart = this.scale > 0 ? (str.slice(0, -this.scale) || '0') : str;
+        let decimalPart = this.scale > 0 ? str.slice(-this.scale) : '';
+        // Apply decimal places if specified
+        if (decimalPlaces !== undefined) {
+            if (decimalPlaces === 0) {
+                return (this.value < 0n ? '-' : '') + integerPart;
+            }
+            decimalPart = decimalPart.padEnd(decimalPlaces, '0').slice(0, decimalPlaces);
+        }
+        // Remove trailing zeros if no specific decimal places requested
+        if (decimalPlaces === undefined) {
+            decimalPart = decimalPart.replace(/0+$/, '');
+        }
+        const result = decimalPart ? `${integerPart}.${decimalPart}` : integerPart;
+        return this.value < 0n ? '-' + result : result;
+    }
+    /**
+     * Convert to number (may lose precision)
+     */
+    toNumber() {
+        return Number(this.value) / Math.pow(10, this.scale);
+    }
+    /**
+     * Convert to fixed decimal places string
+     */
+    toFixed(decimalPlaces) {
+        return this.round(decimalPlaces).toString(decimalPlaces);
+    }
+    /**
+     * Add two decimals
+     */
+    add(other) {
+        const otherDecimal = other instanceof Decimal ? other : new Decimal(other);
+        // Align scales
+        if (this.scale === otherDecimal.scale) {
+            return new Decimal(this.value + otherDecimal.value, this.scale);
+        }
+        const maxScale = Math.max(this.scale, otherDecimal.scale);
+        const thisScaled = this.rescale(maxScale);
+        const otherScaled = otherDecimal.rescale(maxScale);
+        return new Decimal(thisScaled.value + otherScaled.value, maxScale);
+    }
+    /**
+     * Subtract another decimal
+     */
+    subtract(other) {
+        const otherDecimal = other instanceof Decimal ? other : new Decimal(other);
+        // Align scales
+        if (this.scale === otherDecimal.scale) {
+            return new Decimal(this.value - otherDecimal.value, this.scale);
+        }
+        const maxScale = Math.max(this.scale, otherDecimal.scale);
+        const thisScaled = this.rescale(maxScale);
+        const otherScaled = otherDecimal.rescale(maxScale);
+        return new Decimal(thisScaled.value - otherScaled.value, maxScale);
+    }
+    /**
+     * Multiply by another decimal
+     */
+    multiply(other) {
+        const otherDecimal = other instanceof Decimal ? other : new Decimal(other);
+        // Multiply values and add scales
+        const newValue = this.value * otherDecimal.value;
+        const newScale = this.scale + otherDecimal.scale;
+        // Reduce scale if possible to avoid overflow
+        const result = new Decimal(newValue, newScale);
+        return result.normalize();
+    }
+    /**
+     * Divide by another decimal
+     */
+    divide(other, precision = 10) {
+        const otherDecimal = other instanceof Decimal ? other : new Decimal(other);
+        if (otherDecimal.value === 0n) {
+            throw new Error('Division by zero');
+        }
+        // Scale up the dividend to maintain precision
+        const scaledDividend = this.value * BigInt(Math.pow(10, precision));
+        const quotient = scaledDividend / otherDecimal.value;
+        return new Decimal(quotient, this.scale + precision - otherDecimal.scale).normalize();
+    }
+    /**
+     * Calculate percentage (this * rate / 100)
+     */
+    percentage(rate) {
+        const rateDecimal = rate instanceof Decimal ? rate : new Decimal(rate);
+        return this.multiply(rateDecimal).divide(100);
+    }
+    /**
+     * Round to specified decimal places using a specific rounding mode
+     */
+    round(decimalPlaces, mode = 'HALF_UP') {
+        if (decimalPlaces === this.scale) {
+            return this;
+        }
+        if (decimalPlaces > this.scale) {
+            // Just add zeros
+            return this.rescale(decimalPlaces);
+        }
+        // Need to round
+        const factor = BigInt(Math.pow(10, this.scale - decimalPlaces));
+        const halfFactor = factor / 2n;
+        let rounded;
+        const isNegative = this.value < 0n;
+        const absValue = isNegative ? -this.value : this.value;
+        switch (mode) {
+            case 'HALF_UP':
+                // Round half away from zero
+                rounded = (absValue + halfFactor) / factor;
+                break;
+            case 'HALF_DOWN':
+                // Round half toward zero
+                rounded = (absValue + halfFactor - 1n) / factor;
+                break;
+            case 'HALF_EVEN':
+                // Banker's rounding
+                const quotient = absValue / factor;
+                const remainder = absValue % factor;
+                if (remainder > halfFactor || (remainder === halfFactor && quotient % 2n === 1n)) {
+                    rounded = quotient + 1n;
+                }
+                else {
+                    rounded = quotient;
+                }
+                break;
+            case 'UP':
+                // Round away from zero
+                rounded = (absValue + factor - 1n) / factor;
+                break;
+            case 'DOWN':
+                // Round toward zero
+                rounded = absValue / factor;
+                break;
+            case 'CEILING':
+                // Round toward positive infinity
+                if (isNegative) {
+                    rounded = absValue / factor;
+                }
+                else {
+                    rounded = (absValue + factor - 1n) / factor;
+                }
+                break;
+            case 'FLOOR':
+                // Round toward negative infinity
+                if (isNegative) {
+                    rounded = (absValue + factor - 1n) / factor;
+                }
+                else {
+                    rounded = absValue / factor;
+                }
+                break;
+            default:
+                throw new Error(`Unknown rounding mode: ${mode}`);
+        }
+        const finalValue = isNegative ? -rounded : rounded;
+        return new Decimal(finalValue, decimalPlaces);
+    }
+    /**
+     * Compare with another decimal
+     */
+    compareTo(other) {
+        const otherDecimal = other instanceof Decimal ? other : new Decimal(other);
+        // Align scales for comparison
+        if (this.scale === otherDecimal.scale) {
+            if (this.value < otherDecimal.value)
+                return -1;
+            if (this.value > otherDecimal.value)
+                return 1;
+            return 0;
+        }
+        const maxScale = Math.max(this.scale, otherDecimal.scale);
+        const thisScaled = this.rescale(maxScale);
+        const otherScaled = otherDecimal.rescale(maxScale);
+        if (thisScaled.value < otherScaled.value)
+            return -1;
+        if (thisScaled.value > otherScaled.value)
+            return 1;
+        return 0;
+    }
+    /**
+     * Check equality
+     */
+    equals(other, tolerance) {
+        if (tolerance) {
+            const toleranceDecimal = tolerance instanceof Decimal ? tolerance : new Decimal(tolerance);
+            const diff = this.subtract(other);
+            const absDiff = diff.abs();
+            return absDiff.compareTo(toleranceDecimal) <= 0;
+        }
+        return this.compareTo(other) === 0;
+    }
+    /**
+     * Check if less than
+     */
+    lessThan(other) {
+        return this.compareTo(other) < 0;
+    }
+    /**
+     * Check if less than or equal
+     */
+    lessThanOrEqual(other) {
+        return this.compareTo(other) <= 0;
+    }
+    /**
+     * Check if greater than
+     */
+    greaterThan(other) {
+        return this.compareTo(other) > 0;
+    }
+    /**
+     * Check if greater than or equal
+     */
+    greaterThanOrEqual(other) {
+        return this.compareTo(other) >= 0;
+    }
+    /**
+     * Get absolute value
+     */
+    abs() {
+        return this.value < 0n ? new Decimal(-this.value, this.scale) : this;
+    }
+    /**
+     * Negate the value
+     */
+    negate() {
+        return new Decimal(-this.value, this.scale);
+    }
+    /**
+     * Check if zero
+     */
+    isZero() {
+        return this.value === 0n;
+    }
+    /**
+     * Check if negative
+     */
+    isNegative() {
+        return this.value < 0n;
+    }
+    /**
+     * Check if positive
+     */
+    isPositive() {
+        return this.value > 0n;
+    }
+    /**
+     * Rescale to a different number of decimal places
+     */
+    rescale(newScale) {
+        if (newScale === this.scale) {
+            return this;
+        }
+        if (newScale > this.scale) {
+            // Add zeros
+            const factor = BigInt(Math.pow(10, newScale - this.scale));
+            return new Decimal(this.value * factor, newScale);
+        }
+        // This would lose precision, use round() instead
+        throw new Error('Use round() to reduce scale');
+    }
+    /**
+     * Normalize by removing trailing zeros
+     */
+    normalize() {
+        if (this.value === 0n) {
+            return new Decimal(0n, 0);
+        }
+        let value = this.value;
+        let scale = this.scale;
+        while (scale > 0 && value % 10n === 0n) {
+            value = value / 10n;
+            scale--;
+        }
+        return new Decimal(value, scale);
+    }
+    /**
+     * Create a Decimal from a percentage string (e.g., "19%" -> 0.19)
+     */
+    static fromPercentage(value) {
+        const cleaned = value.replace('%', '').trim();
+        return new Decimal(cleaned).divide(100);
+    }
+    /**
+     * Sum an array of decimals
+     */
+    static sum(values) {
+        return values.reduce((acc, val) => {
+            const decimal = val instanceof Decimal ? val : new Decimal(val);
+            return acc.add(decimal);
+        }, Decimal.ZERO);
+    }
+    /**
+     * Get the minimum value
+     */
+    static min(...values) {
+        if (values.length === 0) {
+            throw new Error('No values provided');
+        }
+        let min = values[0] instanceof Decimal ? values[0] : new Decimal(values[0]);
+        for (let i = 1; i < values.length; i++) {
+            const current = values[i] instanceof Decimal ? values[i] : new Decimal(values[i]);
+            const currentDecimal = current instanceof Decimal ? current : new Decimal(current);
+            if (currentDecimal.lessThan(min)) {
+                min = currentDecimal;
+            }
+        }
+        return min;
+    }
+    /**
+     * Get the maximum value
+     */
+    static max(...values) {
+        if (values.length === 0) {
+            throw new Error('No values provided');
+        }
+        let max = values[0] instanceof Decimal ? values[0] : new Decimal(values[0]);
+        for (let i = 1; i < values.length; i++) {
+            const current = values[i] instanceof Decimal ? values[i] : new Decimal(values[i]);
+            const currentDecimal = current instanceof Decimal ? current : new Decimal(current);
+            if (currentDecimal.greaterThan(max)) {
+                max = currentDecimal;
+            }
+        }
+        return max;
+    }
+}
+/**
+ * Helper function to create a Decimal
+ */
+export function decimal(value) {
+    return new Decimal(value);
+}
+/**
+ * Export commonly used rounding modes
+ */
+export const RoundingMode = {
+    HALF_UP: 'HALF_UP',
+    HALF_DOWN: 'HALF_DOWN',
+    HALF_EVEN: 'HALF_EVEN',
+    UP: 'UP',
+    DOWN: 'DOWN',
+    CEILING: 'CEILING',
+    FLOOR: 'FLOOR'
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decimal.js","sourceRoot":"","sources":["../../../ts/formats/utils/decimal.ts"],"names":[],"mappings":"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"}

package/dist_ts/formats/validation/codelist.validator.d.ts

@@ -0,0 +1,49 @@
+import type { ValidationResult } from './validation.types.js';
+import type { EInvoice } from '../../einvoice.js';
+/**
+ * Code List Validator for EN16931 compliance
+ * Validates against standard code lists (ISO, UNCL, UNECE)
+ */
+export declare class CodeListValidator {
+    private results;
+    /**
+     * Validate all code lists in an invoice
+     */
+    validate(invoice: EInvoice): ValidationResult[];
+    /**
+     * Validate currency codes (ISO 4217)
+     */
+    private validateCurrency;
+    /**
+     * Validate country codes (ISO 3166-1 alpha-2)
+     */
+    private validateCountryCodes;
+    /**
+     * Validate document type code (UNCL1001)
+     */
+    private validateDocumentType;
+    /**
+     * Validate tax category codes (UNCL5305)
+     */
+    private validateTaxCategories;
+    /**
+     * Validate payment means codes (UNCL4461)
+     */
+    private validatePaymentMeans;
+    /**
+     * Validate unit codes (UNECE Rec 20)
+     */
+    private validateUnitCodes;
+    /**
+     * Add validation error
+     */
+    private addError;
+    /**
+     * Add validation warning
+     */
+    private addWarning;
+    /**
+     * Get code list metadata for a rule
+     */
+    private getCodeListForRule;
+}