@novha/calc-engines 7.0.0 → 7.0.1

package/src/mortgage/japan/domain/types.ts

@@ -0,0 +1,46 @@
+import { OtherFees } from "../../domain/types";
+
+export interface MortgageRules {
+    loanConstraints: LoanConstraints;
+    interest: InterestRules;
+    acquisitionTax: AcquisitionTaxRules;
+}
+
+export interface LoanConstraints {
+    maxLtvPercent: number;
+    maxAmortizationYears: number;
+}
+
+export interface InterestRules {
+    compounding: 'MONTHLY';
+}
+
+export interface AcquisitionTaxRules {
+    rate: number;
+}
+
+export interface AmortizationScheduleItem {
+    year: number;
+    principal: number;
+    interest: number;
+    balance: number;
+}
+
+export interface MortgageInput {
+    propertyPrice: number;
+    downPayment: number;
+    annualInterestRate: number;
+    amortizationYears: number;
+    isFirstTimeBuyer: boolean;
+}
+
+export interface MortgageOutput {
+    loanAmount: number;
+    totalMortgage: number;
+    monthlyPayment: number;
+    totalInterestPaid: number;
+    totalPaid: number;
+    acquisitionTax: number;
+    amortizationSchedule: AmortizationScheduleItem[];
+    otherFees: OtherFees;
+}

package/src/mortgage/netherlands/NetherlandsMortgageService.ts

@@ -0,0 +1,5 @@
+import { MortgageInput, MortgageOutput, MortgageRules } from "./domain/types";
+
+export interface NetherlandsMortgageService {
+    calculate(input: MortgageInput, rules: MortgageRules): MortgageOutput;
+}

package/src/mortgage/netherlands/NetherlandsMortgageServiceImpl.ts

@@ -0,0 +1,109 @@
+import { NetherlandsMortgageService } from "./NetherlandsMortgageService";
+import { AmortizationScheduleItem, MortgageInput, MortgageOutput, MortgageRules } from "./domain/types";
+
+export class NetherlandsMortgageServiceImpl implements NetherlandsMortgageService {
+
+    public calculate(input: MortgageInput, rules: MortgageRules): MortgageOutput {
+        const loanAmount = input.propertyPrice - input.downPayment;
+
+        if (loanAmount <= 0) {
+            throw new Error('Invalid loan amount: down payment must be less than property price');
+        }
+
+        const totalPayments = input.amortizationYears * 12;
+        const monthlyRate = (input.annualInterestRate / 100) / 12;
+
+        const monthlyPayment = this.calculatePayment(loanAmount, monthlyRate, totalPayments);
+        const totalPaid = monthlyPayment * totalPayments;
+        const totalInterestPaid = totalPaid - loanAmount;
+
+        const transferTaxRate = input.isPrimaryResidence
+            ? rules.transferTax.primaryResidenceRate
+            : rules.transferTax.otherRate;
+        const transferTax = input.propertyPrice * transferTaxRate;
+        const notaryFees = input.propertyPrice * rules.notaryFeeRate;
+        const landRegistryFee = input.propertyPrice * rules.landRegistryFeeRate;
+
+        const amortizationSchedule = this.calculateAmortizationSchedule(
+            loanAmount,
+            monthlyRate,
+            monthlyPayment,
+            totalPayments,
+            input.amortizationYears,
+        );
+
+        return {
+            loanAmount,
+            totalMortgage: loanAmount,
+            monthlyPayment,
+            totalInterestPaid,
+            totalPaid,
+            transferTax,
+            notaryFees,
+            landRegistryFee,
+            amortizationSchedule,
+            otherFees: {
+                notaryFees: {
+                    value: notaryFees,
+                    label: 'NOTARY_FEES',
+                },
+                bankFees: {
+                    value: landRegistryFee,
+                    label: 'LAND_REGISTRY_FEE',
+                },
+                monthlyInsuranceFees: {
+                    value: 0,
+                    label: 'MONTHLY_INSURANCE_FEES',
+                },
+            },
+        };
+    }
+
+    private calculateAmortizationSchedule(
+        principal: number,
+        monthlyRate: number,
+        monthlyPayment: number,
+        totalPayments: number,
+        amortizationYears: number,
+    ): AmortizationScheduleItem[] {
+        const schedule: AmortizationScheduleItem[] = [];
+        let balance = principal;
+
+        for (let year = 1; year <= amortizationYears; year++) {
+            let yearlyPrincipal = 0;
+            let yearlyInterest = 0;
+
+            const paymentsInYear = Math.min(12, totalPayments - (year - 1) * 12);
+
+            for (let payment = 1; payment <= paymentsInYear; payment++) {
+                const interestPayment = balance * monthlyRate;
+                const principalPayment = monthlyPayment - interestPayment;
+
+                yearlyInterest += interestPayment;
+                yearlyPrincipal += principalPayment;
+                balance -= principalPayment;
+            }
+
+            schedule.push({
+                year,
+                principal: yearlyPrincipal,
+                interest: yearlyInterest,
+                balance: Math.max(0, balance),
+            });
+
+            if (balance <= 0) break;
+        }
+
+        return schedule;
+    }
+
+    private calculatePayment(principal: number, rate: number, periods: number): number {
+        if (rate === 0) {
+            return principal / periods;
+        }
+
+        return principal *
+            (rate * Math.pow(1 + rate, periods)) /
+            (Math.pow(1 + rate, periods) - 1);
+    }
+}

package/src/mortgage/netherlands/domain/types.ts

@@ -0,0 +1,37 @@
+import { OtherFees } from "../../domain/types";
+
+export interface MortgageRules {
+    loanConstraints: { maxLtvPercent: number; maxAmortizationYears: number };
+    interest: { compounding: 'MONTHLY' };
+    transferTax: { primaryResidenceRate: number; otherRate: number };
+    notaryFeeRate: number;
+    landRegistryFeeRate: number;
+}
+
+export interface AmortizationScheduleItem {
+    year: number;
+    principal: number;
+    interest: number;
+    balance: number;
+}
+
+export interface MortgageInput {
+    propertyPrice: number;
+    downPayment: number;
+    annualInterestRate: number;
+    amortizationYears: number;
+    isPrimaryResidence: boolean;
+}
+
+export interface MortgageOutput {
+    loanAmount: number;
+    totalMortgage: number;
+    monthlyPayment: number;
+    totalInterestPaid: number;
+    totalPaid: number;
+    transferTax: number;
+    notaryFees: number;
+    landRegistryFee: number;
+    amortizationSchedule: AmortizationScheduleItem[];
+    otherFees: OtherFees;
+}

package/src/mortgage/spain/SpainMortgageService.ts

@@ -0,0 +1,5 @@
+import { MortgageInput, MortgageOutput, MortgageRules } from "./domain/types";
+
+export interface SpainMortgageService {
+    calculate(input: MortgageInput, rules: MortgageRules): MortgageOutput;
+}

package/src/mortgage/spain/SpainMortgageServiceImpl.ts

@@ -0,0 +1,130 @@
+import { SpainMortgageService } from "./SpainMortgageService";
+import { AmortizationScheduleItem, MortgageInput, MortgageOutput, MortgageRules, TransferTaxBracket } from "./domain/types";
+
+export class SpainMortgageServiceImpl implements SpainMortgageService {
+
+    public calculate(input: MortgageInput, rules: MortgageRules): MortgageOutput {
+        const loanAmount = input.propertyPrice - input.downPayment;
+
+        if (loanAmount <= 0) {
+            throw new Error('Invalid loan amount: down payment must be less than property price');
+        }
+
+        const totalPayments = input.amortizationYears * 12;
+        const monthlyRate = (input.annualInterestRate / 100) / 12;
+
+        const monthlyPayment = this.calculatePayment(loanAmount, monthlyRate, totalPayments);
+        const totalPaid = monthlyPayment * totalPayments;
+        const totalInterestPaid = totalPaid - loanAmount;
+
+        const transferTax = this.calculateTransferTax(
+            input.propertyPrice,
+            rules.transferTax.brackets,
+        );
+
+        const amortizationSchedule = this.calculateAmortizationSchedule(
+            loanAmount,
+            monthlyRate,
+            monthlyPayment,
+            totalPayments,
+            input.amortizationYears,
+        );
+
+        return {
+            loanAmount,
+            totalMortgage: loanAmount,
+            monthlyPayment,
+            totalInterestPaid,
+            totalPaid,
+            transferTax,
+            amortizationSchedule,
+            otherFees: {
+                notaryFees: {
+                    value: transferTax,
+                    label: 'TRANSFER_TAX',
+                },
+                bankFees: {
+                    value: 0,
+                    label: 'BANK_FEES',
+                },
+                monthlyInsuranceFees: {
+                    value: 0,
+                    label: 'MONTHLY_INSURANCE_FEES',
+                },
+            },
+        };
+    }
+
+    private calculateTransferTax(
+        propertyPrice: number,
+        brackets: TransferTaxBracket[],
+    ): number {
+        let tax = 0;
+        let previousLimit = 0;
+
+        for (const bracket of brackets) {
+            if (bracket.upTo !== undefined) {
+                if (propertyPrice > previousLimit) {
+                    const taxable = Math.min(propertyPrice, bracket.upTo) - previousLimit;
+                    tax += taxable * bracket.rate;
+                    previousLimit = bracket.upTo;
+                }
+            } else if (bracket.above !== undefined) {
+                if (propertyPrice > bracket.above) {
+                    tax += (propertyPrice - bracket.above) * bracket.rate;
+                }
+                break;
+            }
+        }
+
+        return tax;
+    }
+
+    private calculateAmortizationSchedule(
+        principal: number,
+        monthlyRate: number,
+        monthlyPayment: number,
+        totalPayments: number,
+        amortizationYears: number,
+    ): AmortizationScheduleItem[] {
+        const schedule: AmortizationScheduleItem[] = [];
+        let balance = principal;
+
+        for (let year = 1; year <= amortizationYears; year++) {
+            let yearlyPrincipal = 0;
+            let yearlyInterest = 0;
+
+            const paymentsInYear = Math.min(12, totalPayments - (year - 1) * 12);
+
+            for (let payment = 1; payment <= paymentsInYear; payment++) {
+                const interestPayment = balance * monthlyRate;
+                const principalPayment = monthlyPayment - interestPayment;
+
+                yearlyInterest += interestPayment;
+                yearlyPrincipal += principalPayment;
+                balance -= principalPayment;
+            }
+
+            schedule.push({
+                year,
+                principal: yearlyPrincipal,
+                interest: yearlyInterest,
+                balance: Math.max(0, balance),
+            });
+
+            if (balance <= 0) break;
+        }
+
+        return schedule;
+    }
+
+    private calculatePayment(principal: number, rate: number, periods: number): number {
+        if (rate === 0) {
+            return principal / periods;
+        }
+
+        return principal *
+            (rate * Math.pow(1 + rate, periods)) /
+            (Math.pow(1 + rate, periods) - 1);
+    }
+}

package/src/mortgage/spain/domain/types.ts

@@ -0,0 +1,52 @@
+import { OtherFees } from "../../domain/types";
+
+export interface MortgageRules {
+    loanConstraints: LoanConstraints;
+    interest: InterestRules;
+    transferTax: TransferTaxRules;
+}
+
+export interface LoanConstraints {
+    maxLtvPercent: number;
+    maxAmortizationYears: number;
+}
+
+export interface InterestRules {
+    compounding: 'MONTHLY';
+}
+
+export interface TransferTaxBracket {
+    upTo?: number;
+    above?: number;
+    rate: number;
+}
+
+export interface TransferTaxRules {
+    brackets: TransferTaxBracket[];
+}
+
+export interface AmortizationScheduleItem {
+    year: number;
+    principal: number;
+    interest: number;
+    balance: number;
+}
+
+export interface MortgageInput {
+    propertyPrice: number;
+    downPayment: number;
+    annualInterestRate: number;
+    amortizationYears: number;
+    isFirstTimeBuyer: boolean;
+}
+
+export interface MortgageOutput {
+    loanAmount: number;
+    totalMortgage: number;
+    monthlyPayment: number;
+    totalInterestPaid: number;
+    totalPaid: number;
+    transferTax: number;
+    amortizationSchedule: AmortizationScheduleItem[];
+    otherFees: OtherFees;
+}

package/src/mortgage/switzerland/SwitzerlandMortgageService.ts

@@ -0,0 +1,5 @@
+import { MortgageInput, MortgageOutput, MortgageRules } from "./domain/types";
+
+export interface SwitzerlandMortgageService {
+    calculate(input: MortgageInput, rules: MortgageRules): MortgageOutput;
+}

package/src/mortgage/switzerland/SwitzerlandMortgageServiceImpl.ts

@@ -0,0 +1,106 @@
+import { SwitzerlandMortgageService } from "./SwitzerlandMortgageService";
+import { AmortizationScheduleItem, MortgageInput, MortgageOutput, MortgageRules } from "./domain/types";
+
+export class SwitzerlandMortgageServiceImpl implements SwitzerlandMortgageService {
+
+    public calculate(input: MortgageInput, rules: MortgageRules): MortgageOutput {
+        const loanAmount = input.propertyPrice - input.downPayment;
+
+        if (loanAmount <= 0) {
+            throw new Error('Invalid loan amount: down payment must be less than property price');
+        }
+
+        const totalPayments = input.amortizationYears * 12;
+        const monthlyRate = (input.annualInterestRate / 100) / 12;
+
+        const monthlyPayment = this.calculatePayment(loanAmount, monthlyRate, totalPayments);
+        const totalPaid = monthlyPayment * totalPayments;
+        const totalInterestPaid = totalPaid - loanAmount;
+
+        const transferTax = input.propertyPrice * rules.transferTaxRate;
+        const notaryFees = input.propertyPrice * rules.notaryFeeRate;
+        const landRegistryFee = input.propertyPrice * rules.landRegistryFeeRate;
+
+        const amortizationSchedule = this.calculateAmortizationSchedule(
+            loanAmount,
+            monthlyRate,
+            monthlyPayment,
+            totalPayments,
+            input.amortizationYears,
+        );
+
+        return {
+            loanAmount,
+            totalMortgage: loanAmount,
+            monthlyPayment,
+            totalInterestPaid,
+            totalPaid,
+            transferTax,
+            notaryFees,
+            landRegistryFee,
+            amortizationSchedule,
+            otherFees: {
+                notaryFees: {
+                    value: notaryFees,
+                    label: 'NOTARY_FEES',
+                },
+                bankFees: {
+                    value: landRegistryFee,
+                    label: 'LAND_REGISTRY_FEE',
+                },
+                monthlyInsuranceFees: {
+                    value: 0,
+                    label: 'MONTHLY_INSURANCE_FEES',
+                },
+            },
+        };
+    }
+
+    private calculateAmortizationSchedule(
+        principal: number,
+        monthlyRate: number,
+        monthlyPayment: number,
+        totalPayments: number,
+        amortizationYears: number,
+    ): AmortizationScheduleItem[] {
+        const schedule: AmortizationScheduleItem[] = [];
+        let balance = principal;
+
+        for (let year = 1; year <= amortizationYears; year++) {
+            let yearlyPrincipal = 0;
+            let yearlyInterest = 0;
+
+            const paymentsInYear = Math.min(12, totalPayments - (year - 1) * 12);
+
+            for (let payment = 1; payment <= paymentsInYear; payment++) {
+                const interestPayment = balance * monthlyRate;
+                const principalPayment = monthlyPayment - interestPayment;
+
+                yearlyInterest += interestPayment;
+                yearlyPrincipal += principalPayment;
+                balance -= principalPayment;
+            }
+
+            schedule.push({
+                year,
+                principal: yearlyPrincipal,
+                interest: yearlyInterest,
+                balance: Math.max(0, balance),
+            });
+
+            if (balance <= 0) break;
+        }
+
+        return schedule;
+    }
+
+    private calculatePayment(principal: number, rate: number, periods: number): number {
+        if (rate === 0) {
+            return principal / periods;
+        }
+
+        return principal *
+            (rate * Math.pow(1 + rate, periods)) /
+            (Math.pow(1 + rate, periods) - 1);
+    }
+}

package/src/mortgage/switzerland/domain/types.ts

@@ -0,0 +1,36 @@
+import { OtherFees } from "../../domain/types";
+
+export interface MortgageRules {
+    loanConstraints: { maxLtvPercent: number; maxAmortizationYears: number };
+    interest: { compounding: 'MONTHLY' };
+    transferTaxRate: number;
+    notaryFeeRate: number;
+    landRegistryFeeRate: number;
+}
+
+export interface AmortizationScheduleItem {
+    year: number;
+    principal: number;
+    interest: number;
+    balance: number;
+}
+
+export interface MortgageInput {
+    propertyPrice: number;
+    downPayment: number;
+    annualInterestRate: number;
+    amortizationYears: number;
+}
+
+export interface MortgageOutput {
+    loanAmount: number;
+    totalMortgage: number;
+    monthlyPayment: number;
+    totalInterestPaid: number;
+    totalPaid: number;
+    transferTax: number;
+    notaryFees: number;
+    landRegistryFee: number;
+    amortizationSchedule: AmortizationScheduleItem[];
+    otherFees: OtherFees;
+}

package/test/brazil-capital-gains.test.ts

@@ -0,0 +1,65 @@
+import { BrazilCapitalGainsServiceImpl } from '../src/capital-gains/brazil/BrazilCapitalGainsServiceImpl';
+import { Input, Rules } from '../src/capital-gains/brazil/domain/types';
+
+const brazilRules: Rules = {
+    brackets: [
+        { from: 0, to: 5000000, rate: 0.15 },
+        { from: 5000000, to: 10000000, rate: 0.175 },
+        { from: 10000000, to: 30000000, rate: 0.20 },
+        { from: 30000000, to: null, rate: 0.225 },
+    ],
+};
+
+describe('BrazilCapitalGainsServiceImpl', () => {
+    it('returns zero tax for zero gain', () => {
+        const input: Input = { capitalGain: 0 };
+        const service = new BrazilCapitalGainsServiceImpl(input, brazilRules);
+        const result = service.calculate();
+
+        expect(result.taxableGain).toBe(0);
+        expect(result.capitalGainTax).toBe(0);
+        expect(result.totalTax).toBe(0);
+        expect(result.effectiveRate).toBe(0);
+        expect(result.breakdowns).toHaveLength(0);
+    });
+
+    it('correctly calculates tax for gain in first bracket', () => {
+        const input: Input = { capitalGain: 1000000 };
+        const service = new BrazilCapitalGainsServiceImpl(input, brazilRules);
+        const result = service.calculate();
+
+        // 0-1000000: 1000000 * 0.15 = 150000
+        expect(result.capitalGainTax).toBe(150000);
+        expect(result.totalTax).toBe(150000);
+        expect(result.effectiveRate).toBeCloseTo(15, 2);
+    });
+
+    it('correctly calculates tax spanning multiple brackets', () => {
+        const input: Input = { capitalGain: 7000000 };
+        const service = new BrazilCapitalGainsServiceImpl(input, brazilRules);
+        const result = service.calculate();
+
+        // 0-5000000: 5000000 * 0.15 = 750000
+        // 5000000-7000000: 2000000 * 0.175 = 350000
+        // Total = 1100000
+        expect(result.capitalGainTax).toBeCloseTo(1100000, 2);
+        expect(result.totalTax).toBeCloseTo(1100000, 2);
+        expect(result.effectiveRate).toBeCloseTo((1100000 / 7000000) * 100, 2);
+    });
+
+    it('taxable gain equals input capital gain', () => {
+        const input: Input = { capitalGain: 3000000 };
+        const service = new BrazilCapitalGainsServiceImpl(input, brazilRules);
+        const result = service.calculate();
+
+        expect(result.taxableGain).toBe(3000000);
+    });
+
+    it('returns correct number of breakdown entries', () => {
+        const input: Input = { capitalGain: 7000000 };
+        const service = new BrazilCapitalGainsServiceImpl(input, brazilRules);
+        const result = service.calculate();
+
+        expect(result.breakdowns).toHaveLength(2);
+    });
+});

package/test/brazil-corporate-tax.test.ts

@@ -0,0 +1,63 @@
+import { BrazilCorporateTaxServiceImpl } from '../src/corporate/brazil/BrazilCorporateTaxServiceImpl';
+import { Input, Rules } from '../src/corporate/brazil/domain/types';
+
+const brazilRules: Rules = {
+    irpj: { baseRate: 0.15, surchargeRate: 0.10, surchargeThreshold: 240000 },
+    csll: { rate: 0.09 },
+};
+
+describe('BrazilCorporateTaxServiceImpl', () => {
+    it('returns zero tax for zero income', () => {
+        const input: Input = { taxableIncome: 0 };
+        const service = new BrazilCorporateTaxServiceImpl(input, brazilRules);
+        const result = service.calculate();
+
+        expect(result.corporateTax).toBe(0);
+        expect(result.effectiveTaxRate).toBe(0);
+        expect(result.breakdowns).toHaveLength(0);
+    });
+
+    it('correctly calculates tax for income below the surcharge threshold', () => {
+        const input: Input = { taxableIncome: 200000 };
+        const service = new BrazilCorporateTaxServiceImpl(input, brazilRules);
+        const result = service.calculate();
+
+        // IRPJ base: 200000 * 0.15 = 30000
+        // Surcharge: 0 (200000 <= 240000)
+        // CSLL: 200000 * 0.09 = 18000
+        // Total = 48000
+        expect(result.corporateTax).toBeCloseTo(48000, 2);
+        expect(result.effectiveTaxRate).toBeCloseTo(24, 2);
+    });
+
+    it('correctly calculates tax for income above the surcharge threshold', () => {
+        const input: Input = { taxableIncome: 400000 };
+        const service = new BrazilCorporateTaxServiceImpl(input, brazilRules);
+        const result = service.calculate();
+
+        // IRPJ base: 400000 * 0.15 = 60000
+        // Surcharge: (400000 - 240000) * 0.10 = 16000
+        // CSLL: 400000 * 0.09 = 36000
+        // Total = 112000
+        expect(result.corporateTax).toBeCloseTo(112000, 2);
+        expect(result.effectiveTaxRate).toBeCloseTo(28, 2);
+    });
+
+    it('returns three breakdown entries when surcharge applies', () => {
+        const input: Input = { taxableIncome: 400000 };
+        const service = new BrazilCorporateTaxServiceImpl(input, brazilRules);
+        const result = service.calculate();
+
+        expect(result.breakdowns).toHaveLength(3);
+    });
+
+    it('effective tax rate is higher when income exceeds surcharge threshold', () => {
+        const inputBelow: Input = { taxableIncome: 200000 };
+        const inputAbove: Input = { taxableIncome: 400000 };
+
+        const rateBelow = new BrazilCorporateTaxServiceImpl(inputBelow, brazilRules).calculate().effectiveTaxRate;
+        const rateAbove = new BrazilCorporateTaxServiceImpl(inputAbove, brazilRules).calculate().effectiveTaxRate;
+
+        expect(rateAbove).toBeGreaterThan(rateBelow);
+    });
+});