@novha/calc-engines 7.0.0 → 7.0.1

package/src/corporate/spain/SpainCorporateTaxServiceImpl.ts

@@ -0,0 +1,35 @@
+import { Breakdown } from "../domain/types";
+import { SpainCorporateTaxService } from "./SpainCorporateTaxService";
+import { Input, Result, Rules } from "./domain/types";
+
+export class SpainCorporateTaxServiceImpl implements SpainCorporateTaxService {
+    private _input: Input;
+    private _rules: Rules;
+
+    constructor(input: Input, rules: Rules) {
+        this._input = input;
+        this._rules = rules;
+    }
+
+    calculate(): Result {
+        const income = this._input.taxableIncome;
+
+        if (income <= 0) {
+            return { corporateTax: 0, effectiveTaxRate: 0, breakdowns: [] };
+        }
+
+        const tax = income * this._rules.regime.rate;
+        const breakdowns: Breakdown[] = [{
+            from: '0',
+            to: 'All',
+            rate: this._rules.regime.rate,
+            amount: tax,
+        }];
+
+        return {
+            corporateTax: tax,
+            effectiveTaxRate: (tax / income) * 100,
+            breakdowns,
+        };
+    }
+}

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

@@ -0,0 +1,15 @@
+import { Breakdown } from "../../domain/types";
+
+export interface Rules {
+    regime: { type: 'flat'; rate: number };
+}
+
+export interface Input {
+    taxableIncome: number;
+}
+
+export interface Result {
+    corporateTax: number;
+    effectiveTaxRate: number;
+    breakdowns: Breakdown[];
+}

package/src/corporate/switzerland/SwitzerlandCorporateTaxService.ts

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

package/src/corporate/switzerland/SwitzerlandCorporateTaxServiceImpl.ts

@@ -0,0 +1,35 @@
+import { Breakdown } from "../domain/types";
+import { SwitzerlandCorporateTaxService } from "./SwitzerlandCorporateTaxService";
+import { Input, Result, Rules } from "./domain/types";
+
+export class SwitzerlandCorporateTaxServiceImpl implements SwitzerlandCorporateTaxService {
+    private _input: Input;
+    private _rules: Rules;
+
+    constructor(input: Input, rules: Rules) {
+        this._input = input;
+        this._rules = rules;
+    }
+
+    calculate(): Result {
+        const income = this._input.taxableIncome;
+
+        if (income <= 0) {
+            return { corporateTax: 0, effectiveTaxRate: 0, breakdowns: [] };
+        }
+
+        const tax = income * this._rules.regime.rate;
+        const breakdowns: Breakdown[] = [{
+            from: '0',
+            to: 'All',
+            rate: this._rules.regime.rate,
+            amount: tax,
+        }];
+
+        return {
+            corporateTax: tax,
+            effectiveTaxRate: (tax / income) * 100,
+            breakdowns,
+        };
+    }
+}

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

@@ -0,0 +1,15 @@
+import { Breakdown } from "../../domain/types";
+
+export interface Rules {
+    regime: { type: 'flat'; rate: number };
+}
+
+export interface Input {
+    taxableIncome: number;
+}
+
+export interface Result {
+    corporateTax: number;
+    effectiveTaxRate: number;
+    breakdowns: Breakdown[];
+}

package/src/income-tax/brazil/BrazilIncomeTaxService.ts

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

package/src/income-tax/brazil/BrazilIncomeTaxServiceImpl.ts

@@ -0,0 +1,91 @@
+import { BracketAllocation } from "../domain/types";
+import { BrazilIncomeTaxService } from "./BrazilIncomeTaxService";
+import { ComputedIncomeTaxValues, INSSRules, IncomeTaxRules } from "./domain/types";
+
+export class BrazilIncomeTaxServiceImpl implements BrazilIncomeTaxService {
+    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 inss = this.computeINSS(this._income, this._rules.inss);
+        const totalDeductions = grossTax + inss;
+        const netIncome = this._income - totalDeductions;
+
+        return {
+            grossIncome: this._income,
+            incomeTax: this.round(grossTax),
+            inss: this.round(inss),
+            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;
+
+            if (taxableAmount > 0) {
+                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,
+                });
+            } else {
+                bracketBreakdown.push({
+                    bracketIndex: index,
+                    bracketName: `Bracket ${index + 1}`,
+                    from: bracket.from,
+                    to: bracket.to ?? null,
+                    rate: bracket.rate,
+                    amountInBracket: 0,
+                    taxOnAmount: 0,
+                });
+            }
+        }
+
+        return { grossTax: tax, bracketBreakdown };
+    }
+
+    private computeINSS(income: number, rules: INSSRules): number {
+        return Math.min(income, rules.cap) * rules.rate;
+    }
+
+    private round(value: number, decimals = 2): number {
+        return Number(value.toFixed(decimals));
+    }
+}

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

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

package/src/income-tax/index.ts

@@ -47,6 +47,55 @@ import {
     IncomeTaxRules as GermanyIncomeTaxRules,
 } from './germany/domain/types';
 
+// Brazil
+import { BrazilIncomeTaxServiceImpl as BrazilIncomeTaxService } from './brazil/BrazilIncomeTaxServiceImpl';
+import {
+    ComputedIncomeTaxValues as BrazilComputedIncomeTaxValues,
+    IncomeTaxRules as BrazilIncomeTaxRules,
+} from './brazil/domain/types';
+
+// Spain
+import { SpainIncomeTaxServiceImpl as SpainIncomeTaxService } from './spain/SpainIncomeTaxServiceImpl';
+import {
+    ComputedIncomeTaxValues as SpainComputedIncomeTaxValues,
+    IncomeTaxRules as SpainIncomeTaxRules,
+} from './spain/domain/types';
+
+// India
+import { IndiaIncomeTaxServiceImpl as IndiaIncomeTaxService } from './india/IndiaIncomeTaxServiceImpl';
+import {
+    ComputedIncomeTaxValues as IndiaComputedIncomeTaxValues,
+    IncomeTaxRules as IndiaIncomeTaxRules,
+} from './india/domain/types';
+
+// Japan
+import { JapanIncomeTaxServiceImpl as JapanIncomeTaxService } from './japan/JapanIncomeTaxServiceImpl';
+import {
+    ComputedIncomeTaxValues as JapanComputedIncomeTaxValues,
+    IncomeTaxRules as JapanIncomeTaxRules,
+} from './japan/domain/types';
+
+// Israel
+import { IsraelIncomeTaxServiceImpl as IsraelIncomeTaxService } from './israel/IsraelIncomeTaxServiceImpl';
+import {
+    ComputedIncomeTaxValues as IsraelComputedIncomeTaxValues,
+    IncomeTaxRules as IsraelIncomeTaxRules,
+} from './israel/domain/types';
+
+// Switzerland
+import { SwitzerlandIncomeTaxServiceImpl as SwitzerlandIncomeTaxService } from './switzerland/SwitzerlandIncomeTaxServiceImpl';
+import {
+    ComputedIncomeTaxValues as SwitzerlandComputedIncomeTaxValues,
+    IncomeTaxRules as SwitzerlandIncomeTaxRules,
+} from './switzerland/domain/types';
+
+// Netherlands
+import { NetherlandsIncomeTaxServiceImpl as NetherlandsIncomeTaxService } from './netherlands/NetherlandsIncomeTaxServiceImpl';
+import {
+    ComputedIncomeTaxValues as NetherlandsComputedIncomeTaxValues,
+    IncomeTaxRules as NetherlandsIncomeTaxRules,
+} from './netherlands/domain/types';
+
 export {
     CanadaIncomeTaxService,
     CanadaComputedIncomeTaxValues,
@@ -69,4 +118,25 @@ export {
     GermanyIncomeTaxService,
     GermanyComputedIncomeTaxValues,
     GermanyIncomeTaxRules,
+    BrazilIncomeTaxService,
+    BrazilComputedIncomeTaxValues,
+    BrazilIncomeTaxRules,
+    SpainIncomeTaxService,
+    SpainComputedIncomeTaxValues,
+    SpainIncomeTaxRules,
+    IndiaIncomeTaxService,
+    IndiaComputedIncomeTaxValues,
+    IndiaIncomeTaxRules,
+    JapanIncomeTaxService,
+    JapanComputedIncomeTaxValues,
+    JapanIncomeTaxRules,
+    IsraelIncomeTaxService,
+    IsraelComputedIncomeTaxValues,
+    IsraelIncomeTaxRules,
+    SwitzerlandIncomeTaxService,
+    SwitzerlandComputedIncomeTaxValues,
+    SwitzerlandIncomeTaxRules,
+    NetherlandsIncomeTaxService,
+    NetherlandsComputedIncomeTaxValues,
+    NetherlandsIncomeTaxRules,
 };

package/src/income-tax/india/IndiaIncomeTaxService.ts

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

package/src/income-tax/india/IndiaIncomeTaxServiceImpl.ts

@@ -0,0 +1,87 @@
+import { BracketAllocation } from "../domain/types";
+import { IndiaIncomeTaxService } from "./IndiaIncomeTaxService";
+import { ComputedIncomeTaxValues, IncomeTaxRules } from "./domain/types";
+
+export class IndiaIncomeTaxServiceImpl implements IndiaIncomeTaxService {
+    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 cess = grossTax * this._rules.cess.rate;
+        const totalDeductions = grossTax + cess;
+        const netIncome = this._income - totalDeductions;
+
+        return {
+            grossIncome: this._income,
+            incomeTax: this.round(grossTax),
+            cess: this.round(cess),
+            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;
+
+            if (taxableAmount > 0) {
+                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,
+                });
+            } else {
+                bracketBreakdown.push({
+                    bracketIndex: index,
+                    bracketName: `Bracket ${index + 1}`,
+                    from: bracket.from,
+                    to: bracket.to ?? null,
+                    rate: bracket.rate,
+                    amountInBracket: 0,
+                    taxOnAmount: 0,
+                });
+            }
+        }
+
+        return { grossTax: tax, bracketBreakdown };
+    }
+
+    private round(value: number, decimals = 2): number {
+        return Number(value.toFixed(decimals));
+    }
+}

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

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

package/src/income-tax/israel/IsraelIncomeTaxService.ts

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

package/src/income-tax/israel/IsraelIncomeTaxServiceImpl.ts

@@ -0,0 +1,75 @@
+import { BracketAllocation } from "../domain/types";
+import { IsraelIncomeTaxService } from "./IsraelIncomeTaxService";
+import { ComputedIncomeTaxValues, IncomeTaxRules } from "./domain/types";
+
+export class IsraelIncomeTaxServiceImpl implements IsraelIncomeTaxService {
+    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/israel/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/japan/JapanIncomeTaxService.ts

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

package/src/income-tax/japan/JapanIncomeTaxServiceImpl.ts

@@ -0,0 +1,87 @@
+import { BracketAllocation } from "../domain/types";
+import { JapanIncomeTaxService } from "./JapanIncomeTaxService";
+import { ComputedIncomeTaxValues, IncomeTaxRules } from "./domain/types";
+
+export class JapanIncomeTaxServiceImpl implements JapanIncomeTaxService {
+    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 inhabitantTax = this._income * this._rules.inhabitantTax.rate;
+        const totalDeductions = grossTax + inhabitantTax;
+        const netIncome = this._income - totalDeductions;
+
+        return {
+            grossIncome: this._income,
+            nationalIncomeTax: this.round(grossTax),
+            inhabitantTax: this.round(inhabitantTax),
+            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;
+
+            if (taxableAmount > 0) {
+                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,
+                });
+            } else {
+                bracketBreakdown.push({
+                    bracketIndex: index,
+                    bracketName: `Bracket ${index + 1}`,
+                    from: bracket.from,
+                    to: bracket.to ?? null,
+                    rate: bracket.rate,
+                    amountInBracket: 0,
+                    taxOnAmount: 0,
+                });
+            }
+        }
+
+        return { grossTax: tax, bracketBreakdown };
+    }
+
+    private round(value: number, decimals = 2): number {
+        return Number(value.toFixed(decimals));
+    }
+}

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

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

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

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