@novha/calc-engines 7.0.0 → 8.0.0

package/src/inheritance-tax/japan/JapanInheritanceTaxServiceImpl.ts

@@ -0,0 +1,67 @@
+import { Breakdown } from "../domain/types";
+import { JapanInheritanceTaxService } from "./JapanInheritanceTaxService";
+import { Input, Result, Rules, TaxBracket } from "./domain/types";
+
+export class JapanInheritanceTaxServiceImpl implements JapanInheritanceTaxService {
+    private _input: Input;
+    private _rules: Rules;
+
+    constructor(input: Input, rules: Rules) {
+        this._input = input;
+        this._rules = rules;
+    }
+
+    calculate(): Result {
+        const estate = this._input.estateValue;
+        const heirs = Math.max(1, this._input.numberOfStatutoryHeirs);
+        const exemption = this._rules.baseExemption + this._rules.perHeirExemption * heirs;
+
+        if (estate <= 0 || estate <= exemption) {
+            return {
+                taxableEstate: 0,
+                inheritanceTax: 0,
+                effectiveRate: 0,
+                breakdowns: [],
+            };
+        }
+
+        const taxableEstate = estate - exemption;
+        const { tax, breakdowns } = this.applyBrackets(taxableEstate, this._rules.taxBrackets);
+
+        return {
+            taxableEstate,
+            inheritanceTax: tax,
+            effectiveRate: estate > 0 ? (tax / estate) * 100 : 0,
+            breakdowns,
+        };
+    }
+
+    private applyBrackets(
+        taxableAmount: number,
+        brackets: TaxBracket[],
+    ): { tax: number; breakdowns: Breakdown[] } {
+        let tax = 0;
+        const breakdowns: Breakdown[] = [];
+
+        for (const bracket of brackets) {
+            if (taxableAmount <= bracket.from) break;
+
+            const upper = bracket.to ?? taxableAmount;
+            const taxable = Math.min(upper, taxableAmount) - bracket.from;
+
+            if (taxable > 0) {
+                const bracketTax = taxable * bracket.rate;
+                tax += bracketTax;
+
+                breakdowns.push({
+                    from: `${bracket.from}`,
+                    to: `${bracket.to ?? 'Above'}`,
+                    rate: bracket.rate,
+                    amount: bracketTax,
+                });
+            }
+        }
+
+        return { tax, breakdowns };
+    }
+}

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

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

package/src/inheritance-tax/spain/SpainInheritanceTaxService.ts

@@ -0,0 +1,5 @@
+import { Result } from "./domain/types";
+
+export interface SpainInheritanceTaxService {
+    calculate(): Result;
+}

package/src/inheritance-tax/spain/SpainInheritanceTaxServiceImpl.ts

@@ -0,0 +1,65 @@
+import { Breakdown } from "../domain/types";
+import { SpainInheritanceTaxService } from "./SpainInheritanceTaxService";
+import { Input, Result, Rules, TaxBracket } from "./domain/types";
+
+export class SpainInheritanceTaxServiceImpl implements SpainInheritanceTaxService {
+    private _input: Input;
+    private _rules: Rules;
+
+    constructor(input: Input, rules: Rules) {
+        this._input = input;
+        this._rules = rules;
+    }
+
+    calculate(): Result {
+        const estate = this._input.estateValue;
+
+        if (estate <= 0 || estate <= this._rules.exemption) {
+            return {
+                taxableEstate: 0,
+                inheritanceTax: 0,
+                effectiveRate: 0,
+                breakdowns: [],
+            };
+        }
+
+        const taxableEstate = estate - this._rules.exemption;
+        const { tax, breakdowns } = this.applyBrackets(taxableEstate, this._rules.taxBrackets);
+
+        return {
+            taxableEstate,
+            inheritanceTax: tax,
+            effectiveRate: estate > 0 ? (tax / estate) * 100 : 0,
+            breakdowns,
+        };
+    }
+
+    private applyBrackets(
+        taxableAmount: number,
+        brackets: TaxBracket[],
+    ): { tax: number; breakdowns: Breakdown[] } {
+        let tax = 0;
+        const breakdowns: Breakdown[] = [];
+
+        for (const bracket of brackets) {
+            if (taxableAmount <= bracket.from) break;
+
+            const upper = bracket.to ?? taxableAmount;
+            const taxable = Math.min(upper, taxableAmount) - bracket.from;
+
+            if (taxable > 0) {
+                const bracketTax = taxable * bracket.rate;
+                tax += bracketTax;
+
+                breakdowns.push({
+                    from: `${bracket.from}`,
+                    to: `${bracket.to ?? 'Above'}`,
+                    rate: bracket.rate,
+                    amount: bracketTax,
+                });
+            }
+        }
+
+        return { tax, breakdowns };
+    }
+}

package/src/inheritance-tax/spain/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,38 @@ 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';
+
 export {
     CanadaMortgageService,
     CanadaMortgageRules,
@@ -83,5 +115,21 @@ export {
     GermanyMortgageService,
     GermanyMortgageRules,
     GermanyMortgageInput,
-    GermanyMortgageOutput
+    GermanyMortgageOutput,
+    BrazilMortgageService,
+    BrazilMortgageRules,
+    BrazilMortgageInput,
+    BrazilMortgageOutput,
+    SpainMortgageService,
+    SpainMortgageRules,
+    SpainMortgageInput,
+    SpainMortgageOutput,
+    IndiaMortgageService,
+    IndiaMortgageRules,
+    IndiaMortgageInput,
+    IndiaMortgageOutput,
+    JapanMortgageService,
+    JapanMortgageRules,
+    JapanMortgageInput,
+    JapanMortgageOutput
 };

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/japan/JapanMortgageService.ts

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

package/src/mortgage/japan/JapanMortgageServiceImpl.ts

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