@novha/calc-engines 6.3.0 → 7.0.1

package/src/inheritance-tax/index.ts

@@ -0,0 +1,122 @@
+// 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';
+
+// 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,
+    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,
+    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/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/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/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 };
+    }
+}