@novha/calc-engines 6.3.0 → 7.0.1

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/index.ts

@@ -6,3 +6,4 @@ export * as IncomeTax from './income-tax';
 export * as CorporateTax from './corporate';
 export * as CapitalGain from './capital-gains';
 export * as Mortgage from './mortgage';
+export * as InheritanceTax from './inheritance-tax';

package/src/inheritance-tax/australia/AustraliaInheritanceTaxService.ts

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

package/src/inheritance-tax/australia/AustraliaInheritanceTaxServiceImpl.ts

@@ -0,0 +1,21 @@
+import { AustraliaInheritanceTaxService } from "./AustraliaInheritanceTaxService";
+import { Input, Result, Rules } from "./domain/types";
+
+export class AustraliaInheritanceTaxServiceImpl implements AustraliaInheritanceTaxService {
+    private _input: Input;
+    private _rules: Rules;
+
+    constructor(input: Input, rules: Rules) {
+        this._input = input;
+        this._rules = rules;
+    }
+
+    calculate(): Result {
+        return {
+            taxableEstate: 0,
+            inheritanceTax: 0,
+            effectiveRate: 0,
+            breakdowns: [],
+        };
+    }
+}

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

@@ -0,0 +1,16 @@
+import { Breakdown } from "../../domain/types";
+
+export interface Rules {
+    applicable: false;
+}
+
+export interface Input {
+    estateValue: number;
+}
+
+export interface Result {
+    taxableEstate: number;
+    inheritanceTax: number;
+    effectiveRate: number;
+    breakdowns: Breakdown[];
+}

package/src/inheritance-tax/canada/CanadaInheritanceTaxService.ts

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

package/src/inheritance-tax/canada/CanadaInheritanceTaxServiceImpl.ts

@@ -0,0 +1,65 @@
+import { Breakdown } from "../domain/types";
+import { CanadaInheritanceTaxService } from "./CanadaInheritanceTaxService";
+import { Input, Result, Rules, TaxBracket } from "./domain/types";
+
+export class CanadaInheritanceTaxServiceImpl implements CanadaInheritanceTaxService {
+    private _input: Input;
+    private _rules: Rules;
+
+    constructor(input: Input, rules: Rules) {
+        this._input = input;
+        this._rules = rules;
+    }
+
+    calculate(): Result {
+        const gain = this._input.estateValue - this._input.adjustedCostBase;
+
+        if (gain <= 0) {
+            return {
+                taxableEstate: 0,
+                inheritanceTax: 0,
+                effectiveRate: 0,
+                breakdowns: [],
+            };
+        }
+
+        const taxableGain = gain * this._rules.inclusionRate;
+        const { tax, breakdowns } = this.applyBrackets(taxableGain, this._rules.taxBrackets);
+
+        return {
+            taxableEstate: taxableGain,
+            inheritanceTax: tax,
+            effectiveRate: gain > 0 ? (tax / gain) * 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/canada/domain/types.ts

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

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

@@ -0,0 +1,19 @@
+export interface TaxBracket {
+    from: number;
+    to: number | null;
+    rate: number;
+}
+
+export interface Breakdown {
+    from: string;
+    to: string;
+    rate: number;
+    amount: number;
+}
+
+export interface Result {
+    taxableEstate: number;
+    inheritanceTax: number;
+    effectiveRate: number;
+    breakdowns: Breakdown[];
+}

package/src/inheritance-tax/france/FranceInheritanceTaxService.ts

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

package/src/inheritance-tax/france/FranceInheritanceTaxServiceImpl.ts

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

@@ -0,0 +1,35 @@
+import { Breakdown } from "../../domain/types";
+
+export interface TaxBracket {
+    from: number;
+    to: number | null;
+    rate: number;
+}
+
+export interface RelationshipClass {
+    exemption: number;
+    brackets: TaxBracket[];
+}
+
+export interface Rules {
+    relationships: {
+        spouse: RelationshipClass;
+        child: RelationshipClass;
+        sibling: RelationshipClass;
+        other: RelationshipClass;
+    };
+}
+
+export type RelationshipType = 'spouse' | 'child' | 'sibling' | 'other';
+
+export interface Input {
+    estateValue: number;
+    relationship: RelationshipType;
+}
+
+export interface Result {
+    taxableEstate: number;
+    inheritanceTax: number;
+    effectiveRate: number;
+    breakdowns: Breakdown[];
+}

package/src/inheritance-tax/germany/GermanyInheritanceTaxService.ts

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

package/src/inheritance-tax/germany/GermanyInheritanceTaxServiceImpl.ts

@@ -0,0 +1,66 @@
+import { Breakdown } from "../domain/types";
+import { GermanyInheritanceTaxService } from "./GermanyInheritanceTaxService";
+import { Input, Result, Rules, TaxBracket } from "./domain/types";
+
+export class GermanyInheritanceTaxServiceImpl implements GermanyInheritanceTaxService {
+    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/germany/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 interface Rules {
+    taxClasses: {
+        I: TaxClass;
+        II: TaxClass;
+        III: TaxClass;
+    };
+}
+
+export type TaxClassName = 'I' | 'II' | 'III';
+
+export interface Input {
+    estateValue: number;
+    taxClass: TaxClassName;
+}
+
+export interface Result {
+    taxableEstate: number;
+    inheritanceTax: number;
+    effectiveRate: number;
+    breakdowns: Breakdown[];
+}