@novha/calc-engines 6.3.0 → 7.0.1

package/src/inheritance-tax/usa/domain/types.ts

@@ -0,0 +1,23 @@
+import { Breakdown } from "../../domain/types";
+
+export interface TaxBracket {
+    from: number;
+    to: number | null;
+    rate: number;
+}
+
+export interface Rules {
+    exemption: number;
+    taxBrackets: TaxBracket[];
+}
+
+export interface Input {
+    estateValue: number;
+}
+
+export interface Result {
+    taxableEstate: number;
+    inheritanceTax: number;
+    effectiveRate: number;
+    breakdowns: Breakdown[];
+}

package/src/mortgage/brazil/BrazilMortgageService.ts

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

package/src/mortgage/brazil/BrazilMortgageServiceImpl.ts

@@ -0,0 +1,101 @@
+import { BrazilMortgageService } from "./BrazilMortgageService";
+import { AmortizationScheduleItem, MortgageInput, MortgageOutput, MortgageRules } from "./domain/types";
+
+export class BrazilMortgageServiceImpl implements BrazilMortgageService {
+
+    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 itbi = input.propertyPrice * rules.itbi.rate;
+
+        const amortizationSchedule = this.calculateAmortizationSchedule(
+            loanAmount,
+            monthlyRate,
+            monthlyPayment,
+            totalPayments,
+            input.amortizationYears,
+        );
+
+        return {
+            loanAmount,
+            totalMortgage: loanAmount,
+            monthlyPayment,
+            totalInterestPaid,
+            totalPaid,
+            itbi,
+            amortizationSchedule,
+            otherFees: {
+                notaryFees: {
+                    value: itbi,
+                    label: 'ITBI',
+                },
+                bankFees: {
+                    value: 0,
+                    label: 'BANK_FEES',
+                },
+                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/brazil/domain/types.ts

@@ -0,0 +1,46 @@
+import { OtherFees } from "../../domain/types";
+
+export interface MortgageRules {
+    loanConstraints: LoanConstraints;
+    interest: InterestRules;
+    itbi: ITBIRules;
+}
+
+export interface LoanConstraints {
+    maxLtvPercent: number;
+    maxAmortizationYears: number;
+}
+
+export interface InterestRules {
+    compounding: 'MONTHLY';
+}
+
+export interface ITBIRules {
+    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;
+    itbi: number;
+    amortizationSchedule: AmortizationScheduleItem[];
+    otherFees: OtherFees;
+}

package/src/mortgage/index.ts

@@ -55,6 +55,62 @@ import {
     MortgageOutput as GermanyMortgageOutput,
 } from './germany/domain/types';
 
+// Brazil
+import { BrazilMortgageServiceImpl as BrazilMortgageService } from './brazil/BrazilMortgageServiceImpl';
+import {
+    MortgageRules as BrazilMortgageRules,
+    MortgageInput as BrazilMortgageInput,
+    MortgageOutput as BrazilMortgageOutput,
+} from './brazil/domain/types';
+
+// Spain
+import { SpainMortgageServiceImpl as SpainMortgageService } from './spain/SpainMortgageServiceImpl';
+import {
+    MortgageRules as SpainMortgageRules,
+    MortgageInput as SpainMortgageInput,
+    MortgageOutput as SpainMortgageOutput,
+} from './spain/domain/types';
+
+// India
+import { IndiaMortgageServiceImpl as IndiaMortgageService } from './india/IndiaMortgageServiceImpl';
+import {
+    MortgageRules as IndiaMortgageRules,
+    MortgageInput as IndiaMortgageInput,
+    MortgageOutput as IndiaMortgageOutput,
+} from './india/domain/types';
+
+// Japan
+import { JapanMortgageServiceImpl as JapanMortgageService } from './japan/JapanMortgageServiceImpl';
+import {
+    MortgageRules as JapanMortgageRules,
+    MortgageInput as JapanMortgageInput,
+    MortgageOutput as JapanMortgageOutput,
+} from './japan/domain/types';
+
+// Israel
+import { IsraelMortgageServiceImpl as IsraelMortgageService } from './israel/IsraelMortgageServiceImpl';
+import {
+    MortgageRules as IsraelMortgageRules,
+    MortgageInput as IsraelMortgageInput,
+    MortgageOutput as IsraelMortgageOutput,
+} from './israel/domain/types';
+
+// Switzerland
+import { SwitzerlandMortgageServiceImpl as SwitzerlandMortgageService } from './switzerland/SwitzerlandMortgageServiceImpl';
+import {
+    MortgageRules as SwitzerlandMortgageRules,
+    MortgageInput as SwitzerlandMortgageInput,
+    MortgageOutput as SwitzerlandMortgageOutput,
+} from './switzerland/domain/types';
+
+// Netherlands
+import { NetherlandsMortgageServiceImpl as NetherlandsMortgageService } from './netherlands/NetherlandsMortgageServiceImpl';
+import {
+    MortgageRules as NetherlandsMortgageRules,
+    MortgageInput as NetherlandsMortgageInput,
+    MortgageOutput as NetherlandsMortgageOutput,
+} from './netherlands/domain/types';
+
 export {
     CanadaMortgageService,
     CanadaMortgageRules,
@@ -83,5 +139,33 @@ export {
     GermanyMortgageService,
     GermanyMortgageRules,
     GermanyMortgageInput,
-    GermanyMortgageOutput
+    GermanyMortgageOutput,
+    BrazilMortgageService,
+    BrazilMortgageRules,
+    BrazilMortgageInput,
+    BrazilMortgageOutput,
+    SpainMortgageService,
+    SpainMortgageRules,
+    SpainMortgageInput,
+    SpainMortgageOutput,
+    IndiaMortgageService,
+    IndiaMortgageRules,
+    IndiaMortgageInput,
+    IndiaMortgageOutput,
+    JapanMortgageService,
+    JapanMortgageRules,
+    JapanMortgageInput,
+    JapanMortgageOutput,
+    IsraelMortgageService,
+    IsraelMortgageRules,
+    IsraelMortgageInput,
+    IsraelMortgageOutput,
+    SwitzerlandMortgageService,
+    SwitzerlandMortgageRules,
+    SwitzerlandMortgageInput,
+    SwitzerlandMortgageOutput,
+    NetherlandsMortgageService,
+    NetherlandsMortgageRules,
+    NetherlandsMortgageInput,
+    NetherlandsMortgageOutput,
 };

package/src/mortgage/india/IndiaMortgageService.ts

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

package/src/mortgage/india/IndiaMortgageServiceImpl.ts

@@ -0,0 +1,101 @@
+import { IndiaMortgageService } from "./IndiaMortgageService";
+import { AmortizationScheduleItem, MortgageInput, MortgageOutput, MortgageRules } from "./domain/types";
+
+export class IndiaMortgageServiceImpl implements IndiaMortgageService {
+
+    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 stampDuty = input.propertyPrice * rules.stampDuty.rate;
+
+        const amortizationSchedule = this.calculateAmortizationSchedule(
+            loanAmount,
+            monthlyRate,
+            monthlyPayment,
+            totalPayments,
+            input.amortizationYears,
+        );
+
+        return {
+            loanAmount,
+            totalMortgage: loanAmount,
+            monthlyPayment,
+            totalInterestPaid,
+            totalPaid,
+            stampDuty,
+            amortizationSchedule,
+            otherFees: {
+                notaryFees: {
+                    value: stampDuty,
+                    label: 'STAMP_DUTY',
+                },
+                bankFees: {
+                    value: 0,
+                    label: 'BANK_FEES',
+                },
+                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/india/domain/types.ts

@@ -0,0 +1,46 @@
+import { OtherFees } from "../../domain/types";
+
+export interface MortgageRules {
+    loanConstraints: LoanConstraints;
+    interest: InterestRules;
+    stampDuty: StampDutyRules;
+}
+
+export interface LoanConstraints {
+    maxLtvPercent: number;
+    maxAmortizationYears: number;
+}
+
+export interface InterestRules {
+    compounding: 'MONTHLY';
+}
+
+export interface StampDutyRules {
+    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;
+    stampDuty: number;
+    amortizationSchedule: AmortizationScheduleItem[];
+    otherFees: OtherFees;
+}

package/src/mortgage/israel/IsraelMortgageService.ts

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

package/src/mortgage/israel/IsraelMortgageServiceImpl.ts

@@ -0,0 +1,132 @@
+import { IsraelMortgageService } from "./IsraelMortgageService";
+import { AmortizationScheduleItem, MortgageInput, MortgageOutput, MortgageRules, PurchaseTaxBracket } from "./domain/types";
+
+export class IsraelMortgageServiceImpl implements IsraelMortgageService {
+
+    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 purchaseTax = input.isFirstTimeBuyer
+            ? this.calculatePurchaseTax(input.propertyPrice, rules.purchaseTax.brackets)
+            : input.propertyPrice * 0.08;
+
+        const landRegistrationFee = input.propertyPrice * rules.landRegistrationFeeRate;
+
+        const amortizationSchedule = this.calculateAmortizationSchedule(
+            loanAmount,
+            monthlyRate,
+            monthlyPayment,
+            totalPayments,
+            input.amortizationYears,
+        );
+
+        return {
+            loanAmount,
+            totalMortgage: loanAmount,
+            monthlyPayment,
+            totalInterestPaid,
+            totalPaid,
+            purchaseTax,
+            landRegistrationFee,
+            amortizationSchedule,
+            otherFees: {
+                notaryFees: {
+                    value: purchaseTax,
+                    label: 'PURCHASE_TAX',
+                },
+                bankFees: {
+                    value: landRegistrationFee,
+                    label: 'LAND_REGISTRATION_FEE',
+                },
+                monthlyInsuranceFees: {
+                    value: 0,
+                    label: 'MONTHLY_INSURANCE_FEES',
+                },
+            },
+        };
+    }
+
+    private calculatePurchaseTax(
+        propertyPrice: number,
+        brackets: PurchaseTaxBracket[],
+    ): 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/israel/domain/types.ts

@@ -0,0 +1,41 @@
+import { OtherFees } from "../../domain/types";
+
+export interface PurchaseTaxBracket {
+    upTo?: number;
+    above?: number;
+    rate: number;
+}
+
+export interface MortgageRules {
+    loanConstraints: { maxLtvPercent: number; maxAmortizationYears: number };
+    interest: { compounding: 'MONTHLY' };
+    purchaseTax: { brackets: PurchaseTaxBracket[] };
+    landRegistrationFeeRate: 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;
+    purchaseTax: number;
+    landRegistrationFee: number;
+    amortizationSchedule: AmortizationScheduleItem[];
+    otherFees: OtherFees;
+}

package/src/mortgage/japan/JapanMortgageService.ts

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