@novha/calc-engines 6.3.0 → 7.0.0

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[];
+}

package/src/inheritance-tax/index.ts

@@ -0,0 +1,86 @@
+// Canada
+import { CanadaInheritanceTaxServiceImpl as CanadaInheritanceTaxService } from './canada/CanadaInheritanceTaxServiceImpl';
+import {
+    Input as CanadaInheritanceTaxInput,
+    Rules as CanadaInheritanceTaxRules,
+    Result as CanadaInheritanceTaxResult,
+} from './canada/domain/types';
+
+// France
+import { FranceInheritanceTaxServiceImpl as FranceInheritanceTaxService } from './france/FranceInheritanceTaxServiceImpl';
+import {
+    Input as FranceInheritanceTaxInput,
+    Rules as FranceInheritanceTaxRules,
+    Result as FranceInheritanceTaxResult,
+} from './france/domain/types';
+
+// South Africa
+import { SouthAfricaInheritanceTaxServiceImpl as SouthAfricaInheritanceTaxService } from './south-africa/SouthAfricaInheritanceTaxServiceImpl';
+import {
+    Input as SouthAfricaInheritanceTaxInput,
+    Rules as SouthAfricaInheritanceTaxRules,
+    Result as SouthAfricaInheritanceTaxResult,
+} from './south-africa/domain/types';
+
+// Australia
+import { AustraliaInheritanceTaxServiceImpl as AustraliaInheritanceTaxService } from './australia/AustraliaInheritanceTaxServiceImpl';
+import {
+    Input as AustraliaInheritanceTaxInput,
+    Rules as AustraliaInheritanceTaxRules,
+    Result as AustraliaInheritanceTaxResult,
+} from './australia/domain/types';
+
+// UK
+import { UKInheritanceTaxServiceImpl as UKInheritanceTaxService } from './uk/UKInheritanceTaxServiceImpl';
+import {
+    Input as UKInheritanceTaxInput,
+    Rules as UKInheritanceTaxRules,
+    Result as UKInheritanceTaxResult,
+} from './uk/domain/types';
+
+// USA
+import { USAInheritanceTaxServiceImpl as USAInheritanceTaxService } from './usa/USAInheritanceTaxServiceImpl';
+import {
+    Input as USAInheritanceTaxInput,
+    Rules as USAInheritanceTaxRules,
+    Result as USAInheritanceTaxResult,
+} from './usa/domain/types';
+
+// Germany
+import { GermanyInheritanceTaxServiceImpl as GermanyInheritanceTaxService } from './germany/GermanyInheritanceTaxServiceImpl';
+import {
+    Input as GermanyInheritanceTaxInput,
+    Rules as GermanyInheritanceTaxRules,
+    Result as GermanyInheritanceTaxResult,
+} from './germany/domain/types';
+
+export {
+    CanadaInheritanceTaxService,
+    CanadaInheritanceTaxInput,
+    CanadaInheritanceTaxRules,
+    CanadaInheritanceTaxResult,
+    FranceInheritanceTaxService,
+    FranceInheritanceTaxInput,
+    FranceInheritanceTaxRules,
+    FranceInheritanceTaxResult,
+    SouthAfricaInheritanceTaxService,
+    SouthAfricaInheritanceTaxInput,
+    SouthAfricaInheritanceTaxRules,
+    SouthAfricaInheritanceTaxResult,
+    AustraliaInheritanceTaxService,
+    AustraliaInheritanceTaxInput,
+    AustraliaInheritanceTaxRules,
+    AustraliaInheritanceTaxResult,
+    UKInheritanceTaxService,
+    UKInheritanceTaxInput,
+    UKInheritanceTaxRules,
+    UKInheritanceTaxResult,
+    USAInheritanceTaxService,
+    USAInheritanceTaxInput,
+    USAInheritanceTaxRules,
+    USAInheritanceTaxResult,
+    GermanyInheritanceTaxService,
+    GermanyInheritanceTaxInput,
+    GermanyInheritanceTaxRules,
+    GermanyInheritanceTaxResult,
+};

package/src/inheritance-tax/south-africa/SouthAfricaInheritanceTaxService.ts

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

package/src/inheritance-tax/south-africa/SouthAfricaInheritanceTaxServiceImpl.ts

@@ -0,0 +1,66 @@
+import { Breakdown } from "../domain/types";
+import { SouthAfricaInheritanceTaxService } from "./SouthAfricaInheritanceTaxService";
+import { Input, Result, Rules, TaxBracket } from "./domain/types";
+
+export class SouthAfricaInheritanceTaxServiceImpl implements SouthAfricaInheritanceTaxService {
+    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 netEstate = estate - this._input.deductions;
+
+        if (netEstate <= 0 || netEstate <= this._rules.primaryAbatement) {
+            return {
+                taxableEstate: 0,
+                inheritanceTax: 0,
+                effectiveRate: 0,
+                breakdowns: [],
+            };
+        }
+
+        const taxableEstate = netEstate - this._rules.primaryAbatement;
+        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/south-africa/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 {
+    primaryAbatement: number;
+    taxBrackets: TaxBracket[];
+}
+
+export interface Input {
+    estateValue: number;
+    deductions: number;
+}
+
+export interface Result {
+    taxableEstate: number;
+    inheritanceTax: number;
+    effectiveRate: number;
+    breakdowns: Breakdown[];
+}

package/src/inheritance-tax/uk/UKInheritanceTaxService.ts

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

package/src/inheritance-tax/uk/UKInheritanceTaxServiceImpl.ts

@@ -0,0 +1,46 @@
+import { Breakdown } from "../domain/types";
+import { UKInheritanceTaxService } from "./UKInheritanceTaxService";
+import { Input, Result, Rules } from "./domain/types";
+
+export class UKInheritanceTaxServiceImpl implements UKInheritanceTaxService {
+    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.nilRateBand) {
+            return {
+                taxableEstate: 0,
+                inheritanceTax: 0,
+                effectiveRate: 0,
+                breakdowns: [],
+            };
+        }
+
+        const taxableEstate = estate - this._rules.nilRateBand;
+        const rate = this._input.charitableGivingPercent >= this._rules.charityThreshold
+            ? this._rules.charityRate
+            : this._rules.standardRate;
+        const tax = taxableEstate * rate;
+
+        const breakdowns: Breakdown[] = [{
+            from: `${this._rules.nilRateBand}`,
+            to: 'Above',
+            rate,
+            amount: tax,
+        }];
+
+        return {
+            taxableEstate,
+            inheritanceTax: tax,
+            effectiveRate: estate > 0 ? (tax / estate) * 100 : 0,
+            breakdowns,
+        };
+    }
+}

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

@@ -0,0 +1,20 @@
+import { Breakdown } from "../../domain/types";
+
+export interface Rules {
+    nilRateBand: number;
+    standardRate: number;
+    charityRate: number;
+    charityThreshold: number;
+}
+
+export interface Input {
+    estateValue: number;
+    charitableGivingPercent: number;
+}
+
+export interface Result {
+    taxableEstate: number;
+    inheritanceTax: number;
+    effectiveRate: number;
+    breakdowns: Breakdown[];
+}

package/src/inheritance-tax/usa/USAInheritanceTaxService.ts

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

package/src/inheritance-tax/usa/USAInheritanceTaxServiceImpl.ts

@@ -0,0 +1,65 @@
+import { Breakdown } from "../domain/types";
+import { USAInheritanceTaxService } from "./USAInheritanceTaxService";
+import { Input, Result, Rules, TaxBracket } from "./domain/types";
+
+export class USAInheritanceTaxServiceImpl implements USAInheritanceTaxService {
+    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/usa/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/shared/domain/types.ts

@@ -4,6 +4,7 @@ export enum CalculatorType {
     LOAN = 'LOAN',
     CORPORATE_TAX = 'CORPORATE_TAX',
     CAPITAL_GAINS = 'CAPITAL_GAINS',
+    INHERITANCE_TAX = 'INHERITANCE_TAX',
 }
 
 export interface RuleMeta {

package/test/australia-inheritance-tax.test.ts

@@ -0,0 +1,35 @@
+import { AustraliaInheritanceTaxServiceImpl } from '../src/inheritance-tax/australia/AustraliaInheritanceTaxServiceImpl';
+import { Input, Rules } from '../src/inheritance-tax/australia/domain/types';
+
+const australiaRules: Rules = {
+    applicable: false,
+};
+
+describe('AustraliaInheritanceTaxServiceImpl', () => {
+    it('returns zero tax for any estate value', () => {
+        const input: Input = { estateValue: 1000000 };
+        const service = new AustraliaInheritanceTaxServiceImpl(input, australiaRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+        expect(result.taxableEstate).toBe(0);
+        expect(result.effectiveRate).toBe(0);
+        expect(result.breakdowns).toHaveLength(0);
+    });
+
+    it('returns zero tax for very large estate', () => {
+        const input: Input = { estateValue: 100000000 };
+        const service = new AustraliaInheritanceTaxServiceImpl(input, australiaRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+    });
+
+    it('returns zero tax for zero estate', () => {
+        const input: Input = { estateValue: 0 };
+        const service = new AustraliaInheritanceTaxServiceImpl(input, australiaRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+    });
+});

package/test/canada-inheritance-tax.test.ts

@@ -0,0 +1,62 @@
+import { CanadaInheritanceTaxServiceImpl } from '../src/inheritance-tax/canada/CanadaInheritanceTaxServiceImpl';
+import { Input, Rules } from '../src/inheritance-tax/canada/domain/types';
+
+const canadaRules: Rules = {
+    inclusionRate: 0.50,
+    taxBrackets: [
+        { from: 0, to: 55867, rate: 0.15 },
+        { from: 55867, to: 111733, rate: 0.205 },
+        { from: 111733, to: 154906, rate: 0.26 },
+        { from: 154906, to: 220000, rate: 0.29 },
+        { from: 220000, to: null, rate: 0.33 },
+    ],
+};
+
+describe('CanadaInheritanceTaxServiceImpl', () => {
+    it('returns zero tax when no capital gain (estate = cost base)', () => {
+        const input: Input = { estateValue: 500000, adjustedCostBase: 500000 };
+        const service = new CanadaInheritanceTaxServiceImpl(input, canadaRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+        expect(result.taxableEstate).toBe(0);
+    });
+
+    it('returns zero tax when estate is below cost base', () => {
+        const input: Input = { estateValue: 300000, adjustedCostBase: 500000 };
+        const service = new CanadaInheritanceTaxServiceImpl(input, canadaRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+    });
+
+    it('correctly calculates tax on capital gain at death', () => {
+        const input: Input = { estateValue: 600000, adjustedCostBase: 400000 };
+        const service = new CanadaInheritanceTaxServiceImpl(input, canadaRules);
+        const result = service.calculate();
+
+        // Gain = 200000, taxable gain = 200000 * 0.5 = 100000
+        // 55867 * 0.15 = 8380.05
+        // (100000 - 55867) * 0.205 = 44133 * 0.205 = 9047.265
+        // Total ≈ 17427.315
+        expect(result.taxableEstate).toBe(100000);
+        expect(result.inheritanceTax).toBeCloseTo(17427.315, 2);
+    });
+
+    it('returns zero for zero estate', () => {
+        const input: Input = { estateValue: 0, adjustedCostBase: 0 };
+        const service = new CanadaInheritanceTaxServiceImpl(input, canadaRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+    });
+
+    it('calculates effective rate based on total gain', () => {
+        const input: Input = { estateValue: 600000, adjustedCostBase: 400000 };
+        const service = new CanadaInheritanceTaxServiceImpl(input, canadaRules);
+        const result = service.calculate();
+
+        // Effective rate is relative to the gain (200000), not the included portion
+        expect(result.effectiveRate).toBeCloseTo((result.inheritanceTax / 200000) * 100, 2);
+    });
+});