@novha/calc-engines 7.0.0 → 7.0.1

package/src/income-tax/netherlands/NetherlandsIncomeTaxServiceImpl.ts

@@ -0,0 +1,75 @@
+import { BracketAllocation } from "../domain/types";
+import { NetherlandsIncomeTaxService } from "./NetherlandsIncomeTaxService";
+import { ComputedIncomeTaxValues, IncomeTaxRules } from "./domain/types";
+
+export class NetherlandsIncomeTaxServiceImpl implements NetherlandsIncomeTaxService {
+    private _income: number;
+    private _rules: IncomeTaxRules;
+
+    constructor(income: number, rules: IncomeTaxRules) {
+        this._income = income;
+        this._rules = rules;
+    }
+
+    public calculateNetIncome(): ComputedIncomeTaxValues {
+        const { grossTax, bracketBreakdown } = this.computeTaxBrackets(this._income);
+        const socialContributions = this._income * this._rules.socialContributions.rate;
+        const totalDeductions = grossTax + socialContributions;
+        const netIncome = this._income - totalDeductions;
+
+        return {
+            grossIncome: this._income,
+            incomeTax: this.round(grossTax),
+            socialContributions: this.round(socialContributions),
+            totalDeductions: this.round(totalDeductions),
+            netIncome: this.round(netIncome),
+            effectiveTaxRate: this._income > 0 ? this.round(grossTax / this._income, 4) : 0,
+            taxBracketBreakdown: bracketBreakdown,
+        };
+    }
+
+    private computeTaxBrackets(
+        income: number,
+    ): { grossTax: number; bracketBreakdown: BracketAllocation[] } {
+        let tax = 0;
+        const bracketBreakdown: BracketAllocation[] = [];
+
+        for (let index = 0; index < this._rules.taxBrackets.length; index++) {
+            const bracket = this._rules.taxBrackets[index];
+
+            if (income <= bracket.from) {
+                bracketBreakdown.push({
+                    bracketIndex: index,
+                    bracketName: `Bracket ${index + 1}`,
+                    from: bracket.from,
+                    to: bracket.to ?? null,
+                    rate: bracket.rate,
+                    amountInBracket: 0,
+                    taxOnAmount: 0,
+                });
+                break;
+            }
+
+            const upper = bracket.to ?? income;
+            const taxableAmount = Math.min(upper, income) - bracket.from;
+
+            const taxOnAmount = taxableAmount * bracket.rate;
+            tax += taxOnAmount;
+            bracketBreakdown.push({
+                bracketIndex: index,
+                bracketName: `Bracket ${index + 1}`,
+                from: bracket.from,
+                to: bracket.to ?? null,
+                rate: bracket.rate,
+                amountInBracket: taxableAmount,
+                taxOnAmount,
+            });
+        }
+
+        return { grossTax: tax, bracketBreakdown };
+    }
+
+    private round(value: number, decimals = 2): number {
+        return Number(value.toFixed(decimals));
+    }
+}

package/src/income-tax/netherlands/domain/types.ts

@@ -0,0 +1,16 @@
+import { BracketAllocation, TaxBracket } from "../../domain/types";
+
+export interface IncomeTaxRules {
+    taxBrackets: TaxBracket[];
+    socialContributions: { rate: number };
+}
+
+export interface ComputedIncomeTaxValues {
+    grossIncome: number;
+    incomeTax: number;
+    socialContributions: number;
+    totalDeductions: number;
+    netIncome: number;
+    effectiveTaxRate: number;
+    taxBracketBreakdown: BracketAllocation[];
+}

package/src/income-tax/spain/SpainIncomeTaxService.ts

@@ -0,0 +1,5 @@
+import { ComputedIncomeTaxValues } from "./domain/types";
+
+export interface SpainIncomeTaxService {
+    calculateNetIncome(): ComputedIncomeTaxValues;
+}

package/src/income-tax/spain/SpainIncomeTaxServiceImpl.ts

@@ -0,0 +1,75 @@
+import { BracketAllocation } from "../domain/types";
+import { SpainIncomeTaxService } from "./SpainIncomeTaxService";
+import { ComputedIncomeTaxValues, IncomeTaxRules } from "./domain/types";
+
+export class SpainIncomeTaxServiceImpl implements SpainIncomeTaxService {
+    private _income: number;
+    private _rules: IncomeTaxRules;
+
+    constructor(income: number, rules: IncomeTaxRules) {
+        this._income = income;
+        this._rules = rules;
+    }
+
+    public calculateNetIncome(): ComputedIncomeTaxValues {
+        const { grossTax, bracketBreakdown } = this.computeTaxBrackets(this._income);
+        const socialContributions = this._income * this._rules.socialContributions.rate;
+        const totalDeductions = grossTax + socialContributions;
+        const netIncome = this._income - totalDeductions;
+
+        return {
+            grossIncome: this._income,
+            incomeTax: this.round(grossTax),
+            socialContributions: this.round(socialContributions),
+            totalDeductions: this.round(totalDeductions),
+            netIncome: this.round(netIncome),
+            effectiveTaxRate: this._income > 0 ? this.round(grossTax / this._income, 4) : 0,
+            taxBracketBreakdown: bracketBreakdown,
+        };
+    }
+
+    private computeTaxBrackets(
+        income: number,
+    ): { grossTax: number; bracketBreakdown: BracketAllocation[] } {
+        let tax = 0;
+        const bracketBreakdown: BracketAllocation[] = [];
+
+        for (let index = 0; index < this._rules.taxBrackets.length; index++) {
+            const bracket = this._rules.taxBrackets[index];
+
+            if (income <= bracket.from) {
+                bracketBreakdown.push({
+                    bracketIndex: index,
+                    bracketName: `Bracket ${index + 1}`,
+                    from: bracket.from,
+                    to: bracket.to ?? null,
+                    rate: bracket.rate,
+                    amountInBracket: 0,
+                    taxOnAmount: 0,
+                });
+                break;
+            }
+
+            const upper = bracket.to ?? income;
+            const taxableAmount = Math.min(upper, income) - bracket.from;
+
+            const taxOnAmount = taxableAmount * bracket.rate;
+            tax += taxOnAmount;
+            bracketBreakdown.push({
+                bracketIndex: index,
+                bracketName: `Bracket ${index + 1}`,
+                from: bracket.from,
+                to: bracket.to ?? null,
+                rate: bracket.rate,
+                amountInBracket: taxableAmount,
+                taxOnAmount,
+            });
+        }
+
+        return { grossTax: tax, bracketBreakdown };
+    }
+
+    private round(value: number, decimals = 2): number {
+        return Number(value.toFixed(decimals));
+    }
+}

package/src/income-tax/spain/domain/types.ts

@@ -0,0 +1,16 @@
+import { BracketAllocation, TaxBracket } from "../../domain/types";
+
+export interface IncomeTaxRules {
+    taxBrackets: TaxBracket[];
+    socialContributions: { rate: number };
+}
+
+export interface ComputedIncomeTaxValues {
+    grossIncome: number;
+    incomeTax: number;
+    socialContributions: number;
+    totalDeductions: number;
+    netIncome: number;
+    effectiveTaxRate: number;
+    taxBracketBreakdown: BracketAllocation[];
+}

package/src/income-tax/switzerland/SwitzerlandIncomeTaxService.ts

@@ -0,0 +1,5 @@
+import { ComputedIncomeTaxValues } from "./domain/types";
+
+export interface SwitzerlandIncomeTaxService {
+    calculateNetIncome(): ComputedIncomeTaxValues;
+}

package/src/income-tax/switzerland/SwitzerlandIncomeTaxServiceImpl.ts

@@ -0,0 +1,75 @@
+import { BracketAllocation } from "../domain/types";
+import { SwitzerlandIncomeTaxService } from "./SwitzerlandIncomeTaxService";
+import { ComputedIncomeTaxValues, IncomeTaxRules } from "./domain/types";
+
+export class SwitzerlandIncomeTaxServiceImpl implements SwitzerlandIncomeTaxService {
+    private _income: number;
+    private _rules: IncomeTaxRules;
+
+    constructor(income: number, rules: IncomeTaxRules) {
+        this._income = income;
+        this._rules = rules;
+    }
+
+    public calculateNetIncome(): ComputedIncomeTaxValues {
+        const { grossTax, bracketBreakdown } = this.computeTaxBrackets(this._income);
+        const socialContributions = this._income * this._rules.socialContributions.rate;
+        const totalDeductions = grossTax + socialContributions;
+        const netIncome = this._income - totalDeductions;
+
+        return {
+            grossIncome: this._income,
+            incomeTax: this.round(grossTax),
+            socialContributions: this.round(socialContributions),
+            totalDeductions: this.round(totalDeductions),
+            netIncome: this.round(netIncome),
+            effectiveTaxRate: this._income > 0 ? this.round(grossTax / this._income, 4) : 0,
+            taxBracketBreakdown: bracketBreakdown,
+        };
+    }
+
+    private computeTaxBrackets(
+        income: number,
+    ): { grossTax: number; bracketBreakdown: BracketAllocation[] } {
+        let tax = 0;
+        const bracketBreakdown: BracketAllocation[] = [];
+
+        for (let index = 0; index < this._rules.taxBrackets.length; index++) {
+            const bracket = this._rules.taxBrackets[index];
+
+            if (income <= bracket.from) {
+                bracketBreakdown.push({
+                    bracketIndex: index,
+                    bracketName: `Bracket ${index + 1}`,
+                    from: bracket.from,
+                    to: bracket.to ?? null,
+                    rate: bracket.rate,
+                    amountInBracket: 0,
+                    taxOnAmount: 0,
+                });
+                break;
+            }
+
+            const upper = bracket.to ?? income;
+            const taxableAmount = Math.min(upper, income) - bracket.from;
+
+            const taxOnAmount = taxableAmount * bracket.rate;
+            tax += taxOnAmount;
+            bracketBreakdown.push({
+                bracketIndex: index,
+                bracketName: `Bracket ${index + 1}`,
+                from: bracket.from,
+                to: bracket.to ?? null,
+                rate: bracket.rate,
+                amountInBracket: taxableAmount,
+                taxOnAmount,
+            });
+        }
+
+        return { grossTax: tax, bracketBreakdown };
+    }
+
+    private round(value: number, decimals = 2): number {
+        return Number(value.toFixed(decimals));
+    }
+}

package/src/income-tax/switzerland/domain/types.ts

@@ -0,0 +1,16 @@
+import { BracketAllocation, TaxBracket } from "../../domain/types";
+
+export interface IncomeTaxRules {
+    taxBrackets: TaxBracket[];
+    socialContributions: { rate: number };
+}
+
+export interface ComputedIncomeTaxValues {
+    grossIncome: number;
+    incomeTax: number;
+    socialContributions: number;
+    totalDeductions: number;
+    netIncome: number;
+    effectiveTaxRate: number;
+    taxBracketBreakdown: BracketAllocation[];
+}

package/src/inheritance-tax/index.ts

@@ -54,6 +54,30 @@ import {
     Result as GermanyInheritanceTaxResult,
 } from './germany/domain/types';
 
+// Spain
+import { SpainInheritanceTaxServiceImpl as SpainInheritanceTaxService } from './spain/SpainInheritanceTaxServiceImpl';
+import {
+    Input as SpainInheritanceTaxInput,
+    Rules as SpainInheritanceTaxRules,
+    Result as SpainInheritanceTaxResult,
+} from './spain/domain/types';
+
+// Japan
+import { JapanInheritanceTaxServiceImpl as JapanInheritanceTaxService } from './japan/JapanInheritanceTaxServiceImpl';
+import {
+    Input as JapanInheritanceTaxInput,
+    Rules as JapanInheritanceTaxRules,
+    Result as JapanInheritanceTaxResult,
+} from './japan/domain/types';
+
+// Netherlands
+import { NetherlandsInheritanceTaxServiceImpl as NetherlandsInheritanceTaxService } from './netherlands/NetherlandsInheritanceTaxServiceImpl';
+import {
+    Input as NetherlandsInheritanceTaxInput,
+    Rules as NetherlandsInheritanceTaxRules,
+    Result as NetherlandsInheritanceTaxResult,
+} from './netherlands/domain/types';
+
 export {
     CanadaInheritanceTaxService,
     CanadaInheritanceTaxInput,
@@ -83,4 +107,16 @@ export {
     GermanyInheritanceTaxInput,
     GermanyInheritanceTaxRules,
     GermanyInheritanceTaxResult,
+    SpainInheritanceTaxService,
+    SpainInheritanceTaxInput,
+    SpainInheritanceTaxRules,
+    SpainInheritanceTaxResult,
+    JapanInheritanceTaxService,
+    JapanInheritanceTaxInput,
+    JapanInheritanceTaxRules,
+    JapanInheritanceTaxResult,
+    NetherlandsInheritanceTaxService,
+    NetherlandsInheritanceTaxInput,
+    NetherlandsInheritanceTaxRules,
+    NetherlandsInheritanceTaxResult,
 };

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

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

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/netherlands/NetherlandsInheritanceTaxService.ts

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

package/src/inheritance-tax/netherlands/NetherlandsInheritanceTaxServiceImpl.ts

@@ -0,0 +1,66 @@
+import { Breakdown } from "../domain/types";
+import { NetherlandsInheritanceTaxService } from "./NetherlandsInheritanceTaxService";
+import { Input, Result, Rules, TaxBracket } from "./domain/types";
+
+export class NetherlandsInheritanceTaxServiceImpl implements NetherlandsInheritanceTaxService {
+    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 taxClass = this._rules.taxClasses[this._input.taxClass];
+
+        if (estate <= 0 || estate <= taxClass.exemption) {
+            return {
+                taxableEstate: 0,
+                inheritanceTax: 0,
+                effectiveRate: 0,
+                breakdowns: [],
+            };
+        }
+
+        const taxableEstate = estate - taxClass.exemption;
+        const { tax, breakdowns } = this.applyBrackets(taxableEstate, taxClass.brackets);
+
+        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/netherlands/domain/types.ts

@@ -0,0 +1,34 @@
+import { Breakdown } from "../../domain/types";
+
+export interface TaxBracket {
+    from: number;
+    to: number | null;
+    rate: number;
+}
+
+export interface TaxClass {
+    exemption: number;
+    brackets: TaxBracket[];
+}
+
+export type TaxClassName = 'Partner' | 'Child' | 'Other';
+
+export interface Rules {
+    taxClasses: {
+        Partner: TaxClass;
+        Child: TaxClass;
+        Other: TaxClass;
+    };
+}
+
+export interface Input {
+    estateValue: number;
+    taxClass: TaxClassName;
+}
+
+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;
+}