@novha/calc-engines 7.0.0 → 7.0.1

package/src/capital-gains/israel/IsraelCapitalGainsServiceImpl.ts

@@ -0,0 +1,69 @@
+import { Breakdown, Result } from "../domain/types";
+import { IsraelCapitalGainsService } from "./IsraelCapitalGainsService";
+import { CapitalGainsBracket, Input, Rules } from "./domain/types";
+
+export class IsraelCapitalGainsServiceImpl implements IsraelCapitalGainsService {
+    private _input: Input;
+    private _rules: Rules;
+
+    constructor(input: Input, rules: Rules) {
+        this._input = input;
+        this._rules = rules;
+    }
+
+    calculate(): Result {
+        const gain = this._input.capitalGain;
+
+        if (gain <= 0) {
+            return {
+                taxableGain: 0,
+                capitalGainTax: 0,
+                socialContributions: 0,
+                netInvestmentIncomeTax: 0,
+                totalTax: 0,
+                effectiveRate: 0,
+                breakdowns: [],
+            };
+        }
+
+        const { tax, breakdowns } = this.applyBrackets(gain, this._rules.brackets);
+
+        return {
+            taxableGain: gain,
+            capitalGainTax: tax,
+            socialContributions: 0,
+            netInvestmentIncomeTax: 0,
+            totalTax: tax,
+            effectiveRate: (tax / gain) * 100,
+            breakdowns,
+        };
+    }
+
+    private applyBrackets(
+        gain: number,
+        brackets: CapitalGainsBracket[],
+    ): { tax: number; breakdowns: Breakdown[] } {
+        let tax = 0;
+        const breakdowns: Breakdown[] = [];
+
+        for (const bracket of brackets) {
+            if (gain <= bracket.from) break;
+
+            const upper = bracket.to ?? gain;
+            const taxable = Math.min(upper, gain) - 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/capital-gains/israel/domain/types.ts

@@ -0,0 +1,15 @@
+import { Breakdown } from "../../domain/types";
+
+export interface CapitalGainsBracket {
+    from: number;
+    to: number | null;
+    rate: number;
+}
+
+export interface Rules {
+    brackets: CapitalGainsBracket[];
+}
+
+export interface Input {
+    capitalGain: number;
+}

package/src/capital-gains/japan/JapanCapitalGainsService.ts

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

package/src/capital-gains/japan/JapanCapitalGainsServiceImpl.ts

@@ -0,0 +1,47 @@
+import { Breakdown, Result } from "../domain/types";
+import { JapanCapitalGainsService } from "./JapanCapitalGainsService";
+import { Input, Rules } from "./domain/types";
+
+export class JapanCapitalGainsServiceImpl implements JapanCapitalGainsService {
+    private _input: Input;
+    private _rules: Rules;
+
+    constructor(input: Input, rules: Rules) {
+        this._input = input;
+        this._rules = rules;
+    }
+
+    calculate(): Result {
+        const gain = this._input.capitalGain;
+
+        if (gain <= 0) {
+            return {
+                taxableGain: 0,
+                capitalGainTax: 0,
+                socialContributions: 0,
+                netInvestmentIncomeTax: 0,
+                totalTax: 0,
+                effectiveRate: 0,
+                breakdowns: [],
+            };
+        }
+
+        const tax = gain * this._rules.flatRate;
+        const breakdowns: Breakdown[] = [{
+            from: '0',
+            to: 'All',
+            rate: this._rules.flatRate,
+            amount: tax,
+        }];
+
+        return {
+            taxableGain: gain,
+            capitalGainTax: tax,
+            socialContributions: 0,
+            netInvestmentIncomeTax: 0,
+            totalTax: tax,
+            effectiveRate: (tax / gain) * 100,
+            breakdowns,
+        };
+    }
+}

package/src/capital-gains/japan/domain/types.ts

@@ -0,0 +1,9 @@
+import { Breakdown } from "../../domain/types";
+
+export interface Rules {
+    flatRate: number;
+}
+
+export interface Input {
+    capitalGain: number;
+}

package/src/capital-gains/spain/SpainCapitalGainsService.ts

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

package/src/capital-gains/spain/SpainCapitalGainsServiceImpl.ts

@@ -0,0 +1,69 @@
+import { Breakdown, Result } from "../domain/types";
+import { SpainCapitalGainsService } from "./SpainCapitalGainsService";
+import { CapitalGainsBracket, Input, Rules } from "./domain/types";
+
+export class SpainCapitalGainsServiceImpl implements SpainCapitalGainsService {
+    private _input: Input;
+    private _rules: Rules;
+
+    constructor(input: Input, rules: Rules) {
+        this._input = input;
+        this._rules = rules;
+    }
+
+    calculate(): Result {
+        const gain = this._input.capitalGain;
+
+        if (gain <= 0) {
+            return {
+                taxableGain: 0,
+                capitalGainTax: 0,
+                socialContributions: 0,
+                netInvestmentIncomeTax: 0,
+                totalTax: 0,
+                effectiveRate: 0,
+                breakdowns: [],
+            };
+        }
+
+        const { tax, breakdowns } = this.applyBrackets(gain, this._rules.brackets);
+
+        return {
+            taxableGain: gain,
+            capitalGainTax: tax,
+            socialContributions: 0,
+            netInvestmentIncomeTax: 0,
+            totalTax: tax,
+            effectiveRate: (tax / gain) * 100,
+            breakdowns,
+        };
+    }
+
+    private applyBrackets(
+        gain: number,
+        brackets: CapitalGainsBracket[],
+    ): { tax: number; breakdowns: Breakdown[] } {
+        let tax = 0;
+        const breakdowns: Breakdown[] = [];
+
+        for (const bracket of brackets) {
+            if (gain <= bracket.from) break;
+
+            const upper = bracket.to ?? gain;
+            const taxable = Math.min(upper, gain) - 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/capital-gains/spain/domain/types.ts

@@ -0,0 +1,15 @@
+import { Breakdown } from "../../domain/types";
+
+export interface CapitalGainsBracket {
+    from: number;
+    to: number | null;
+    rate: number;
+}
+
+export interface Rules {
+    brackets: CapitalGainsBracket[];
+}
+
+export interface Input {
+    capitalGain: number;
+}

package/src/corporate/brazil/BrazilCorporateTaxService.ts

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

package/src/corporate/brazil/BrazilCorporateTaxServiceImpl.ts

@@ -0,0 +1,40 @@
+import { Breakdown } from "../domain/types";
+import { BrazilCorporateTaxService } from "./BrazilCorporateTaxService";
+import { Input, Result, Rules } from "./domain/types";
+
+export class BrazilCorporateTaxServiceImpl implements BrazilCorporateTaxService {
+    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 irpjBase = income * this._rules.irpj.baseRate;
+        const surcharge = income > this._rules.irpj.surchargeThreshold
+            ? (income - this._rules.irpj.surchargeThreshold) * this._rules.irpj.surchargeRate
+            : 0;
+        const csll = income * this._rules.csll.rate;
+        const corporateTax = irpjBase + surcharge + csll;
+
+        const breakdowns: Breakdown[] = [
+            { from: '0', to: 'All', rate: this._rules.irpj.baseRate, amount: irpjBase },
+            { from: `${this._rules.irpj.surchargeThreshold}`, to: 'Surcharge', rate: this._rules.irpj.surchargeRate, amount: surcharge },
+            { from: '0', to: 'CSLL', rate: this._rules.csll.rate, amount: csll },
+        ];
+
+        return {
+            corporateTax,
+            effectiveTaxRate: (corporateTax / income) * 100,
+            breakdowns,
+        };
+    }
+}

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

@@ -0,0 +1,16 @@
+import { Breakdown } from "../../domain/types";
+
+export interface Rules {
+    irpj: { baseRate: number; surchargeRate: number; surchargeThreshold: number };
+    csll: { rate: number };
+}
+
+export interface Input {
+    taxableIncome: number;
+}
+
+export interface Result {
+    corporateTax: number;
+    effectiveTaxRate: number;
+    breakdowns: Breakdown[];
+}

package/src/corporate/index.ts

@@ -47,6 +47,58 @@ import {
     Result as CanadaCorporateTaxResult,
 } from './canada/domain/types';
 
+import { BrazilCorporateTaxServiceImpl as BrazilCorporateTaxService } from './brazil/BrazilCorporateTaxServiceImpl';
+import {
+    Input as BrazilCorporateTaxInput,
+    Rules as BrazilCorporateTaxRules,
+    Result as BrazilCorporateTaxResult,
+} from './brazil/domain/types';
+
+import { SpainCorporateTaxServiceImpl as SpainCorporateTaxService } from './spain/SpainCorporateTaxServiceImpl';
+import {
+    Input as SpainCorporateTaxInput,
+    Rules as SpainCorporateTaxRules,
+    Result as SpainCorporateTaxResult,
+} from './spain/domain/types';
+
+import { IndiaCorporateTaxServiceImpl as IndiaCorporateTaxService } from './india/IndiaCorporateTaxServiceImpl';
+import {
+    Input as IndiaCorporateTaxInput,
+    Rules as IndiaCorporateTaxRules,
+    Result as IndiaCorporateTaxResult,
+} from './india/domain/types';
+
+import { JapanCorporateTaxServiceImpl as JapanCorporateTaxService } from './japan/JapanCorporateTaxServiceImpl';
+import {
+    Input as JapanCorporateTaxInput,
+    Rules as JapanCorporateTaxRules,
+    Result as JapanCorporateTaxResult,
+} from './japan/domain/types';
+
+// Israel
+import { IsraelCorporateTaxServiceImpl as IsraelCorporateTaxService } from './israel/IsraelCorporateTaxServiceImpl';
+import {
+    Input as IsraelCorporateTaxInput,
+    Rules as IsraelCorporateTaxRules,
+    Result as IsraelCorporateTaxResult,
+} from './israel/domain/types';
+
+// Switzerland
+import { SwitzerlandCorporateTaxServiceImpl as SwitzerlandCorporateTaxService } from './switzerland/SwitzerlandCorporateTaxServiceImpl';
+import {
+    Input as SwitzerlandCorporateTaxInput,
+    Rules as SwitzerlandCorporateTaxRules,
+    Result as SwitzerlandCorporateTaxResult,
+} from './switzerland/domain/types';
+
+// Netherlands
+import { NetherlandsCorporateTaxServiceImpl as NetherlandsCorporateTaxService } from './netherlands/NetherlandsCorporateTaxServiceImpl';
+import {
+    Input as NetherlandsCorporateTaxInput,
+    Rules as NetherlandsCorporateTaxRules,
+    Result as NetherlandsCorporateTaxResult,
+} from './netherlands/domain/types';
+
 export {
     USACorporateTaxService,
     USACorporateTaxInput,
@@ -75,5 +127,33 @@ export {
     CanadaCorporateTaxService,
     CanadaCorporateTaxInput,
     CanadaCorporateTaxRules,
-    CanadaCorporateTaxResult
+    CanadaCorporateTaxResult,
+    BrazilCorporateTaxService,
+    BrazilCorporateTaxInput,
+    BrazilCorporateTaxRules,
+    BrazilCorporateTaxResult,
+    SpainCorporateTaxService,
+    SpainCorporateTaxInput,
+    SpainCorporateTaxRules,
+    SpainCorporateTaxResult,
+    IndiaCorporateTaxService,
+    IndiaCorporateTaxInput,
+    IndiaCorporateTaxRules,
+    IndiaCorporateTaxResult,
+    JapanCorporateTaxService,
+    JapanCorporateTaxInput,
+    JapanCorporateTaxRules,
+    JapanCorporateTaxResult,
+    IsraelCorporateTaxService,
+    IsraelCorporateTaxInput,
+    IsraelCorporateTaxRules,
+    IsraelCorporateTaxResult,
+    SwitzerlandCorporateTaxService,
+    SwitzerlandCorporateTaxInput,
+    SwitzerlandCorporateTaxRules,
+    SwitzerlandCorporateTaxResult,
+    NetherlandsCorporateTaxService,
+    NetherlandsCorporateTaxInput,
+    NetherlandsCorporateTaxRules,
+    NetherlandsCorporateTaxResult,
 };

package/src/corporate/india/IndiaCorporateTaxService.ts

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

package/src/corporate/india/IndiaCorporateTaxServiceImpl.ts

@@ -0,0 +1,35 @@
+import { Breakdown } from "../domain/types";
+import { IndiaCorporateTaxService } from "./IndiaCorporateTaxService";
+import { Input, Result, Rules } from "./domain/types";
+
+export class IndiaCorporateTaxServiceImpl implements IndiaCorporateTaxService {
+    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/india/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/israel/IsraelCorporateTaxService.ts

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

package/src/corporate/israel/IsraelCorporateTaxServiceImpl.ts

@@ -0,0 +1,35 @@
+import { Breakdown } from "../domain/types";
+import { IsraelCorporateTaxService } from "./IsraelCorporateTaxService";
+import { Input, Result, Rules } from "./domain/types";
+
+export class IsraelCorporateTaxServiceImpl implements IsraelCorporateTaxService {
+    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/israel/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/japan/JapanCorporateTaxService.ts

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

package/src/corporate/japan/JapanCorporateTaxServiceImpl.ts

@@ -0,0 +1,35 @@
+import { Breakdown } from "../domain/types";
+import { JapanCorporateTaxService } from "./JapanCorporateTaxService";
+import { Input, Result, Rules } from "./domain/types";
+
+export class JapanCorporateTaxServiceImpl implements JapanCorporateTaxService {
+    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/japan/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/netherlands/NetherlandsCorporateTaxService.ts

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

package/src/corporate/netherlands/NetherlandsCorporateTaxServiceImpl.ts

@@ -0,0 +1,48 @@
+import { Breakdown } from "../domain/types";
+import { NetherlandsCorporateTaxService } from "./NetherlandsCorporateTaxService";
+import { Input, Result, Rules } from "./domain/types";
+
+export class NetherlandsCorporateTaxServiceImpl implements NetherlandsCorporateTaxService {
+    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: [] };
+        }
+
+        let tax = 0;
+        const breakdowns: Breakdown[] = [];
+
+        for (const tier of this._rules.tiers) {
+            if (income <= tier.from) break;
+
+            const upper = tier.to ?? income;
+            const taxable = Math.min(upper, income) - tier.from;
+
+            if (taxable > 0) {
+                const tierTax = taxable * tier.rate;
+                tax += tierTax;
+                breakdowns.push({
+                    from: `${tier.from}`,
+                    to: `${tier.to ?? 'Above'}`,
+                    rate: tier.rate,
+                    amount: tierTax,
+                });
+            }
+        }
+
+        return {
+            corporateTax: tax,
+            effectiveTaxRate: (tax / income) * 100,
+            breakdowns,
+        };
+    }
+}

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

@@ -0,0 +1,21 @@
+import { Breakdown } from "../../domain/types";
+
+export interface TaxTier {
+    from: number;
+    to: number | null;
+    rate: number;
+}
+
+export interface Rules {
+    tiers: TaxTier[];
+}
+
+export interface Input {
+    taxableIncome: number;
+}
+
+export interface Result {
+    corporateTax: number;
+    effectiveTaxRate: number;
+    breakdowns: Breakdown[];
+}

package/src/corporate/spain/SpainCorporateTaxService.ts

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