@novha/calc-engines 4.0.0 → 6.0.0

package/src/capital-gains/index.ts

@@ -0,0 +1,72 @@
+// Capital Gains - Canada
+import { CanadaCapitalGainsServiceImpl as CanadaCapitalGainsService } from './canada/CanadaCapitalGainsServiceImpl';
+import {
+    Input as CanadaCapitalGainsInput,
+    Rules as CanadaCapitalGainsRules
+} from './canada/domain/types';
+
+// Capital Gains - France
+import { FranceCapitalGainsServiceImpl as FranceCapitalGainsService } from './france/FranceCapitalGainsServiceImpl';
+import {
+    Input as FranceCapitalGainsInput,
+    Rules as FranceCapitalGainsRules
+} from './france/domain/types';
+
+// Capital Gains - South Africa
+import { SouthAfricaCapitalGainsServiceImpl as SouthAfricaCapitalGainsService } from './south-africa/SouthAfricaCapitalGainsServiceImpl';
+import {
+    Input as SouthAfricaCapitalGainsInput,
+    Rules as SouthAfricaCapitalGainsRules
+} from './south-africa/domain/types';
+
+// Capital Gains - Australia
+import { AustraliaCapitalGainsServiceImpl as AustraliaCapitalGainsService } from './australia/AustraliaCapitalGainsServiceImpl';
+import {
+    Input as AustraliaCapitalGainsInput,
+    Rules as AustraliaCapitalGainsRules
+} from './australia/domain/types';
+
+// Capital Gains - UK
+import { UKCapitalGainsServiceImpl as UKCapitalGainsService } from './uk/UKCapitalGainsServiceImpl';
+import {
+    Input as UKCapitalGainsInput,
+    Rules as UKCapitalGainsRules
+} from './uk/domain/types';
+
+// Capital Gains - USA
+import { USACapitalGainsServiceImpl as USACapitalGainsService } from './usa/USACapitalGainsServiceImpl';
+import {
+    Input as USACapitalGainsInput,
+    Rules as USACapitalGainsRules
+} from './usa/domain/types';
+
+// Capital Gains - Germany
+import { GermanyCapitalGainsServiceImpl as GermanyCapitalGainsService } from './germany/GermanyCapitalGainsServiceImpl';
+import {
+    Input as GermanyCapitalGainsInput,
+    Rules as GermanyCapitalGainsRules
+} from './germany/domain/types';
+
+export {
+    CanadaCapitalGainsService,
+    CanadaCapitalGainsInput,
+    CanadaCapitalGainsRules,
+    FranceCapitalGainsService,
+    FranceCapitalGainsInput,
+    FranceCapitalGainsRules,
+    SouthAfricaCapitalGainsService,
+    SouthAfricaCapitalGainsInput,
+    SouthAfricaCapitalGainsRules,
+    AustraliaCapitalGainsService,
+    AustraliaCapitalGainsInput,
+    AustraliaCapitalGainsRules,
+    UKCapitalGainsService,
+    UKCapitalGainsInput,
+    UKCapitalGainsRules,
+    USACapitalGainsService,
+    USACapitalGainsInput,
+    USACapitalGainsRules,
+    GermanyCapitalGainsService,
+    GermanyCapitalGainsInput,
+    GermanyCapitalGainsRules
+};

package/src/capital-gains/south-africa/SouthAfricaCapitalGainsService.ts

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

package/src/capital-gains/south-africa/SouthAfricaCapitalGainsServiceImpl.ts

@@ -0,0 +1,101 @@
+import { Breakdown, Result } from "../domain/types";
+import { SouthAfricaCapitalGainsService } from "./SouthAfricaCapitalGainsService";
+import { Input, Rules, TaxBracket } from "./domain/types";
+
+export class SouthAfricaCapitalGainsServiceImpl implements SouthAfricaCapitalGainsService {
+    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 netGain = Math.max(0, gain - this._rules.annualExclusion);
+        const taxableGain = netGain * this._rules.inclusionRate;
+
+        if (taxableGain <= 0) {
+            return {
+                taxableGain: 0,
+                capitalGainTax: 0,
+                socialContributions: 0,
+                netInvestmentIncomeTax: 0,
+                totalTax: 0,
+                effectiveRate: 0,
+                breakdowns: [{
+                    from: '0',
+                    to: `${this._rules.annualExclusion}`,
+                    rate: 0,
+                    amount: 0,
+                }],
+            };
+        }
+
+        const otherIncome = this._input.totalTaxableIncome - gain;
+        const { tax, breakdowns } = this.applyBrackets(taxableGain, otherIncome, this._rules.taxBrackets);
+
+        return {
+            taxableGain,
+            capitalGainTax: tax,
+            socialContributions: 0,
+            netInvestmentIncomeTax: 0,
+            totalTax: tax,
+            effectiveRate: gain > 0 ? (tax / gain) * 100 : 0,
+            breakdowns,
+        };
+    }
+
+    private applyBrackets(
+        taxableGain: number,
+        otherIncome: number,
+        brackets: TaxBracket[],
+    ): { tax: number; breakdowns: Breakdown[] } {
+        let tax = 0;
+        const breakdowns: Breakdown[] = [];
+        let remaining = taxableGain;
+        let incomeUsed = otherIncome;
+
+        for (const bracket of brackets) {
+            if (remaining <= 0) break;
+
+            const upper = bracket.to ?? Infinity;
+
+            if (incomeUsed >= upper) continue;
+
+            const bracketStart = Math.max(bracket.from, incomeUsed);
+            const bracketSpace = upper - bracketStart;
+            const taxable = Math.min(bracketSpace, remaining);
+
+            if (taxable > 0) {
+                const bracketTax = taxable * bracket.rate;
+                tax += bracketTax;
+                remaining -= taxable;
+                incomeUsed += taxable;
+
+                breakdowns.push({
+                    from: `${bracket.from}`,
+                    to: `${bracket.to ?? 'Above'}`,
+                    rate: bracket.rate,
+                    amount: bracketTax,
+                });
+            }
+        }
+
+        return { tax, breakdowns };
+    }
+}

package/src/capital-gains/south-africa/domain/types.ts

@@ -0,0 +1,16 @@
+export interface TaxBracket {
+    from: number;
+    to: number | null;
+    rate: number;
+}
+
+export interface Rules {
+    inclusionRate: number;
+    annualExclusion: number;
+    taxBrackets: TaxBracket[];
+}
+
+export interface Input {
+    capitalGain: number;
+    totalTaxableIncome: number;
+}

package/src/capital-gains/uk/UKCapitalGainsService.ts

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

package/src/capital-gains/uk/UKCapitalGainsServiceImpl.ts

@@ -0,0 +1,98 @@
+import { Breakdown, Result } from "../domain/types";
+import { UKCapitalGainsService } from "./UKCapitalGainsService";
+import { Input, Rules } from "./domain/types";
+
+export class UKCapitalGainsServiceImpl implements UKCapitalGainsService {
+    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 taxableGain = Math.max(0, gain - this._rules.annualExemption);
+
+        if (taxableGain <= 0) {
+            return {
+                taxableGain: 0,
+                capitalGainTax: 0,
+                socialContributions: 0,
+                netInvestmentIncomeTax: 0,
+                totalTax: 0,
+                effectiveRate: 0,
+                breakdowns: [{
+                    from: '0',
+                    to: `${this._rules.annualExemption}`,
+                    rate: 0,
+                    amount: 0,
+                }],
+            };
+        }
+
+        const basicRateRemaining = Math.max(0, this._rules.basicRateLimit - this._input.totalTaxableIncome);
+        const breakdowns: Breakdown[] = [];
+        let tax = 0;
+
+        if (basicRateRemaining > 0) {
+            const basicRateGain = Math.min(taxableGain, basicRateRemaining);
+            const basicTax = basicRateGain * this._rules.basicRate;
+            tax += basicTax;
+
+            breakdowns.push({
+                from: '0',
+                to: `${basicRateRemaining}`,
+                rate: this._rules.basicRate,
+                amount: basicTax,
+            });
+
+            const higherRateGain = taxableGain - basicRateGain;
+            if (higherRateGain > 0) {
+                const higherTax = higherRateGain * this._rules.higherRate;
+                tax += higherTax;
+
+                breakdowns.push({
+                    from: `${basicRateRemaining}`,
+                    to: 'Above',
+                    rate: this._rules.higherRate,
+                    amount: higherTax,
+                });
+            }
+        } else {
+            const higherTax = taxableGain * this._rules.higherRate;
+            tax += higherTax;
+
+            breakdowns.push({
+                from: '0',
+                to: 'Above',
+                rate: this._rules.higherRate,
+                amount: higherTax,
+            });
+        }
+
+        return {
+            taxableGain,
+            capitalGainTax: tax,
+            socialContributions: 0,
+            netInvestmentIncomeTax: 0,
+            totalTax: tax,
+            effectiveRate: gain > 0 ? (tax / gain) * 100 : 0,
+            breakdowns,
+        };
+    }
+}

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

@@ -0,0 +1,11 @@
+export interface Rules {
+    annualExemption: number;
+    basicRate: number;
+    higherRate: number;
+    basicRateLimit: number;
+}
+
+export interface Input {
+    capitalGain: number;
+    totalTaxableIncome: number;
+}

package/src/capital-gains/usa/USACapitalGainsService.ts

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

package/src/capital-gains/usa/USACapitalGainsServiceImpl.ts

@@ -0,0 +1,96 @@
+import { Breakdown, Result } from "../domain/types";
+import { USACapitalGainsService } from "./USACapitalGainsService";
+import { Input, LongTermBracket, Rules } from "./domain/types";
+
+export class USACapitalGainsServiceImpl implements USACapitalGainsService {
+    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 isLongTerm = this._input.holdingPeriodMonths > 12;
+        const brackets = isLongTerm ? this._rules.longTermBrackets : this._rules.shortTermBrackets;
+
+        const { tax, breakdowns } = this.applyBrackets(gain, this._input.totalTaxableIncome, brackets);
+
+        let niit = 0;
+        if (this._input.totalTaxableIncome > this._rules.netInvestmentIncomeTax.threshold) {
+            niit = gain * this._rules.netInvestmentIncomeTax.rate;
+            breakdowns.push({
+                from: 'NIIT',
+                to: 'All Gain',
+                rate: this._rules.netInvestmentIncomeTax.rate,
+                amount: niit,
+            });
+        }
+
+        const totalTax = tax + niit;
+
+        return {
+            taxableGain: gain,
+            capitalGainTax: tax,
+            socialContributions: 0,
+            netInvestmentIncomeTax: niit,
+            totalTax,
+            effectiveRate: gain > 0 ? (totalTax / gain) * 100 : 0,
+            breakdowns,
+        };
+    }
+
+    private applyBrackets(
+        gain: number,
+        totalIncome: number,
+        brackets: LongTermBracket[],
+    ): { tax: number; breakdowns: Breakdown[] } {
+        let tax = 0;
+        const breakdowns: Breakdown[] = [];
+        let remaining = gain;
+        let incomeUsed = totalIncome - gain;
+
+        for (const bracket of brackets) {
+            if (remaining <= 0) break;
+
+            const upper = bracket.to ?? Infinity;
+
+            if (incomeUsed >= upper) continue;
+
+            const bracketStart = Math.max(bracket.from, incomeUsed);
+            const bracketSpace = upper - bracketStart;
+            const taxable = Math.min(bracketSpace, remaining);
+
+            if (taxable > 0) {
+                const bracketTax = taxable * bracket.rate;
+                tax += bracketTax;
+                remaining -= taxable;
+                incomeUsed += taxable;
+
+                breakdowns.push({
+                    from: `${bracket.from}`,
+                    to: `${bracket.to ?? 'Above'}`,
+                    rate: bracket.rate,
+                    amount: bracketTax,
+                });
+            }
+        }
+
+        return { tax, breakdowns };
+    }
+}

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

@@ -0,0 +1,27 @@
+import { Breakdown } from "../../domain/types";
+
+export interface LongTermBracket {
+    from: number;
+    to: number | null;
+    rate: number;
+}
+
+export interface Rules {
+    longTermBrackets: LongTermBracket[];
+    shortTermBrackets: LongTermBracket[];
+    netInvestmentIncomeTax: { rate: number; threshold: number };
+}
+
+export interface Input {
+    capitalGain: number;
+    totalTaxableIncome: number;
+    holdingPeriodMonths: number;
+}
+
+export interface Result {
+    capitalGainsTax: number;
+    netInvestmentIncomeTax: number;
+    totalTax: number;
+    effectiveRate: number;
+    breakdowns: Breakdown[];
+}

package/src/corporate/index.ts

@@ -0,0 +1,79 @@
+import { USACorporateTaxServiceImpl as USACorporateTaxService } from './usa/USACorporateTaxServiceImpl';
+import {
+    Input as USACorporateTaxInput,
+    Rules as USACorporateTaxRules,
+    Result as USACorporateTaxResult,
+} from './usa/domain/types';
+
+import { GermanyCorporateTaxServiceImpl as GermanyCorporateTaxService } from './germany/GermanyCorporateTaxServiceImpl';
+import {
+    Input as GermanyCorporateTaxInput,
+    Rules as GermanyCorporateTaxRules,
+    Result as GermanyCorporateTaxResult,
+} from './germany/domain/types';
+
+import { UKCorporateTaxServiceImpl as UKCorporateTaxService } from './uk/UKCorporateTaxServiceImpl';
+import {
+    Input as UKCorporateTaxInput,
+    Rules as UKCorporateTaxRules,
+    Result as UKCorporateTaxResult,
+} from './uk/domain/types';
+
+import { AustraliaCorporateTaxServiceImpl as AustraliaCorporateTaxService } from './australia/AustraliaCorporateTaxServiceImpl';
+import {
+    Input as AustraliaCorporateTaxInput,
+    Rules as AustraliaCorporateTaxRules,
+    Result as AustraliaCorporateTaxResult,
+} from './australia/domain/types';
+
+import { SouthAfricaCorporateTaxServiceImpl as SouthAfricaCorporateTaxService } from './south-africa/SouthAfricaCorporateTaxServiceImpl';
+import {
+    Rules as SouthAfricaCorporateTaxRules,
+    Input as SouthAfricaCorporateTaxInput,
+    Result as SouthAfricaCorporateTaxResult,
+} from './south-africa/domain/types';
+
+import { FranceCorporateTaxServiceImpl as FranceCorporateTaxService } from './france/FranceCorporateTaxServiceImpl';
+import {
+    Input as FranceCorporateTaxInput,
+    Rules as FranceCorporateTaxRules,
+    Result as FranceCorporateTaxResult,
+} from './france/domain/types';
+
+import { CanadaCorporateTaxServiceImpl as CanadaCorporateTaxService } from './canada/CanadaCorporateTaxServiceImpl';
+import {
+    Input as CanadaCorporateTaxInput,
+    Rules as CanadaCorporateTaxRules,
+    Result as CanadaCorporateTaxResult,
+} from './canada/domain/types';
+
+export {
+    USACorporateTaxService,
+    USACorporateTaxInput,
+    USACorporateTaxRules,
+    USACorporateTaxResult,
+    GermanyCorporateTaxService,
+    GermanyCorporateTaxInput,
+    GermanyCorporateTaxRules,
+    GermanyCorporateTaxResult,
+    UKCorporateTaxService,
+    UKCorporateTaxInput,
+    UKCorporateTaxRules,
+    UKCorporateTaxResult,
+    AustraliaCorporateTaxService,
+    AustraliaCorporateTaxInput,
+    AustraliaCorporateTaxRules,
+    AustraliaCorporateTaxResult,
+    SouthAfricaCorporateTaxService,
+    SouthAfricaCorporateTaxInput,
+    SouthAfricaCorporateTaxRules,
+    SouthAfricaCorporateTaxResult,
+    FranceCorporateTaxService,
+    FranceCorporateTaxInput,
+    FranceCorporateTaxRules,
+    FranceCorporateTaxResult,
+    CanadaCorporateTaxService,
+    CanadaCorporateTaxInput,
+    CanadaCorporateTaxRules,
+    CanadaCorporateTaxResult
+};

package/src/income-tax/index.ts

@@ -0,0 +1,72 @@
+// Canada
+import { CanadaIncomeTaxServiceImpl as CanadaIncomeTaxService } from './canada/CanadaIncomeTaxServiceImpl';
+import {
+    ComputedIncomeTaxValues as CanadaComputedIncomeTaxValues,
+    IncomeTaxRules as CanadaIncomeTaxRules,
+} from './canada/domain/types';
+import { FranceIncomeTaxServiceImpl as FranceIncomeTaxService } from './france/FranceIncomeTaxServiceImpl';
+
+// France
+import { 
+    ComputedIncomeTaxValues as FranceComputedIncomeTaxValues,
+    IncomeTaxRules as FranceIncomeTaxRules,
+} from './france/domain/types';
+
+// South Africa
+import { SouthAfricaIncomeTaxServiceImpl as SouthAfricaIncomeTaxService } from './south-africa/SouthAfricaIncomeTaxServiceImpl';
+import {
+    ComputedIncomeTaxValues as SouthAfricaComputedIncomeTaxValues,
+    IncomeTaxRules as SouthAfricaIncomeTaxRules,
+} from './south-africa/domain/types';
+
+// Australia
+import { AustraliaIncomeTaxServiceImpl as AustraliaIncomeTaxService } from './australia/AustraliaIncomeTaxServiceImpl';
+import {
+    ComputedIncomeTaxValues as AustraliaComputedIncomeTaxValues,
+    IncomeTaxRules as AustraliaIncomeTaxRules,
+} from './australia/domain/types';
+
+// UK
+import { UKIncomeTaxServiceImpl as UKIncomeTaxService } from './uk/UKIncomeTaxServiceImpl';
+import {
+    ComputedIncomeTaxValues as UKComputedIncomeTaxValues,
+    IncomeTaxRules as UKIncomeTaxRules,
+} from './uk/domain/types';
+
+// USA
+import { USAIncomeTaxServiceImpl as USAIncomeTaxService } from './usa/USAIncomeTaxServiceImpl';
+import {
+    ComputedIncomeTaxValues as USAComputedIncomeTaxValues,
+    IncomeTaxRules as USAIncomeTaxRules,
+} from './usa/domain/types';
+
+// Germany
+import { GermanyIncomeTaxServiceImpl as GermanyIncomeTaxService } from './germany/GermanyIncomeTaxServiceImpl';
+import {
+    ComputedIncomeTaxValues as GermanyComputedIncomeTaxValues,
+    IncomeTaxRules as GermanyIncomeTaxRules,
+} from './germany/domain/types';
+
+export {
+    CanadaIncomeTaxService,
+    CanadaComputedIncomeTaxValues,
+    CanadaIncomeTaxRules,
+    FranceIncomeTaxService,
+    FranceComputedIncomeTaxValues,
+    FranceIncomeTaxRules,
+    SouthAfricaIncomeTaxService,
+    SouthAfricaComputedIncomeTaxValues,
+    SouthAfricaIncomeTaxRules,
+    AustraliaIncomeTaxService,
+    AustraliaComputedIncomeTaxValues,
+    AustraliaIncomeTaxRules,
+    UKIncomeTaxService,
+    UKComputedIncomeTaxValues,
+    UKIncomeTaxRules,
+    USAIncomeTaxService,
+    USAComputedIncomeTaxValues,
+    USAIncomeTaxRules,
+    GermanyIncomeTaxService,
+    GermanyComputedIncomeTaxValues,
+    GermanyIncomeTaxRules,
+};