@novha/calc-engines 2.0.3 → 4.0.0

package/dist/types/income-tax/uk/UKIncomeTaxServiceImpl.d.ts

@@ -0,0 +1,12 @@
+import { UKIncomeTaxService } from "./UKIncomeTaxService";
+import { ComputedIncomeTaxValues, IncomeTaxRules } from "./domain/types";
+export declare class UKIncomeTaxServiceImpl implements UKIncomeTaxService {
+    private _income;
+    private _rules;
+    constructor(income: number, rules: IncomeTaxRules);
+    calculateNetIncome(): ComputedIncomeTaxValues;
+    private computePersonalAllowance;
+    private computeTaxBrackets;
+    private computeNationalInsurance;
+    private round;
+}

package/dist/types/income-tax/uk/domain/types.d.ts

@@ -0,0 +1,27 @@
+import { BracketAllocation, TaxBracket } from "../../domain/types";
+export interface IncomeTaxRules {
+    taxBrackets: TaxBracket[];
+    personalAllowance: PersonalAllowanceRules;
+    nationalInsurance: NationalInsuranceRules;
+}
+export interface PersonalAllowanceRules {
+    amount: number;
+    taperThreshold: number;
+    taperRate: number;
+}
+export interface NationalInsuranceRules {
+    primaryThreshold: number;
+    upperEarningsLimit: number;
+    mainRate: number;
+    upperRate: number;
+}
+export interface ComputedIncomeTaxValues {
+    grossIncome: number;
+    incomeTax: number;
+    nationalInsurance: number;
+    personalAllowance: number;
+    totalDeductions: number;
+    netIncome: number;
+    effectiveTaxRate: number;
+    taxBracketBreakdown: BracketAllocation[];
+}

package/dist/types/income-tax/usa/USAIncomeTaxService.d.ts

@@ -0,0 +1,4 @@
+import { ComputedIncomeTaxValues } from "./domain/types";
+export interface USAIncomeTaxService {
+    calculateNetIncome(): ComputedIncomeTaxValues;
+}

package/dist/types/income-tax/usa/USAIncomeTaxServiceImpl.d.ts

@@ -0,0 +1,11 @@
+import { USAIncomeTaxService } from "./USAIncomeTaxService";
+import { ComputedIncomeTaxValues, IncomeTaxRules } from "./domain/types";
+export declare class USAIncomeTaxServiceImpl implements USAIncomeTaxService {
+    private _income;
+    private _rules;
+    constructor(income: number, rules: IncomeTaxRules);
+    calculateNetIncome(): ComputedIncomeTaxValues;
+    private computeTaxBrackets;
+    private computeFICA;
+    private round;
+}

package/dist/types/income-tax/usa/domain/types.d.ts

@@ -0,0 +1,30 @@
+import { BracketAllocation, TaxBracket } from "../../domain/types";
+export interface IncomeTaxRules {
+    taxBrackets: TaxBracket[];
+    standardDeduction: {
+        amount: number;
+    };
+    fica: FICAContributionRules;
+}
+export interface FICAContributionRules {
+    socialSecurity: {
+        rate: number;
+        wageBase: number;
+    };
+    medicare: {
+        rate: number;
+        additionalRate: number;
+        additionalThreshold: number;
+    };
+}
+export interface ComputedIncomeTaxValues {
+    grossIncome: number;
+    incomeTax: number;
+    socialSecurity: number;
+    medicare: number;
+    standardDeduction: number;
+    totalDeductions: number;
+    netIncome: number;
+    effectiveTaxRate: number;
+    taxBracketBreakdown: BracketAllocation[];
+}

package/dist/types/index.d.ts

@@ -23,5 +23,23 @@ export { AustraliaMortgageServiceImpl as AustraliaMortgageService } from './mort
 export { MortgageRules as AustraliaMortgageRules, MortgageInput as AustraliaMortgageInput, MortgageOutput as AustraliaMortgageOutput, } from './mortgage/australia/domain/types';
 export { AustraliaCorporateTaxServiceImpl as AustraliaCorporateTaxService } from './corporate/australia/AustraliaCorporateTaxServiceImpl';
 export { Input as AustraliaCorporateTaxInput, Rules as AustraliaCorporateTaxRules, Result as AustraliaCorporateTaxResult, } from './corporate/australia/domain/types';
+export { UKIncomeTaxServiceImpl as UKIncomeTaxService } from './income-tax/uk/UKIncomeTaxServiceImpl';
+export { ComputedIncomeTaxValues as UKComputedIncomeTaxValues, IncomeTaxRules as UKIncomeTaxRules, } from './income-tax/uk/domain/types';
+export { UKCorporateTaxServiceImpl as UKCorporateTaxService } from './corporate/uk/UKCorporateTaxServiceImpl';
+export { Input as UKCorporateTaxInput, Rules as UKCorporateTaxRules, Result as UKCorporateTaxResult, } from './corporate/uk/domain/types';
+export { UKMortgageServiceImpl as UKMortgageService } from './mortgage/uk/UKMortgageServiceImpl';
+export { MortgageRules as UKMortgageRules, MortgageInput as UKMortgageInput, MortgageOutput as UKMortgageOutput, } from './mortgage/uk/domain/types';
+export { USAIncomeTaxServiceImpl as USAIncomeTaxService } from './income-tax/usa/USAIncomeTaxServiceImpl';
+export { ComputedIncomeTaxValues as USAComputedIncomeTaxValues, IncomeTaxRules as USAIncomeTaxRules, } from './income-tax/usa/domain/types';
+export { USAMortgageServiceImpl as USAMortgageService } from './mortgage/usa/USAMortgageServiceImpl';
+export { MortgageRules as USAMortgageRules, MortgageInput as USAMortgageInput, MortgageOutput as USAMortgageOutput, } from './mortgage/usa/domain/types';
+export { USACorporateTaxServiceImpl as USACorporateTaxService } from './corporate/usa/USACorporateTaxServiceImpl';
+export { Input as USACorporateTaxInput, Rules as USACorporateTaxRules, Result as USACorporateTaxResult, } from './corporate/usa/domain/types';
+export { GermanyIncomeTaxServiceImpl as GermanyIncomeTaxService } from './income-tax/germany/GermanyIncomeTaxServiceImpl';
+export { ComputedIncomeTaxValues as GermanyComputedIncomeTaxValues, IncomeTaxRules as GermanyIncomeTaxRules, } from './income-tax/germany/domain/types';
+export { GermanyMortgageServiceImpl as GermanyMortgageService } from './mortgage/germany/GermanyMortgageServiceImpl';
+export { MortgageRules as GermanyMortgageRules, MortgageInput as GermanyMortgageInput, MortgageOutput as GermanyMortgageOutput, } from './mortgage/germany/domain/types';
+export { GermanyCorporateTaxServiceImpl as GermanyCorporateTaxService } from './corporate/germany/GermanyCorporateTaxServiceImpl';
+export { Input as GermanyCorporateTaxInput, Rules as GermanyCorporateTaxRules, Result as GermanyCorporateTaxResult, } from './corporate/germany/domain/types';
 export { IncomeTaxCalculatorSchema } from './income-tax/domain/types';
 export * from './income-tax/domain/types';

package/dist/types/mortgage/germany/GermanyMortgageService.d.ts

@@ -0,0 +1,4 @@
+import { MortgageInput, MortgageOutput, MortgageRules } from "./domain/types";
+export interface GermanyMortgageService {
+    calculate(input: MortgageInput, rules: MortgageRules): MortgageOutput;
+}

package/dist/types/mortgage/germany/GermanyMortgageServiceImpl.d.ts

@@ -0,0 +1,7 @@
+import { GermanyMortgageService } from "./GermanyMortgageService";
+import { MortgageInput, MortgageOutput, MortgageRules } from "./domain/types";
+export declare class GermanyMortgageServiceImpl implements GermanyMortgageService {
+    calculate(input: MortgageInput, rules: MortgageRules): MortgageOutput;
+    private calculateAmortizationSchedule;
+    private calculatePayment;
+}

package/dist/types/mortgage/germany/domain/types.d.ts

@@ -0,0 +1,42 @@
+import { OtherFees } from "../../domain/types";
+export interface MortgageRules {
+    loanConstraints: LoanConstraints;
+    interest: InterestRules;
+    landTransferTax: LandTransferTaxRules;
+    notaryFeeRate: number;
+    registrationFeeRate: number;
+}
+export interface LoanConstraints {
+    maxLtvPercent: number;
+    maxAmortizationYears: number;
+}
+export interface InterestRules {
+    compounding: 'MONTHLY';
+}
+export interface LandTransferTaxRules {
+    rate: number;
+}
+export interface AmortizationScheduleItem {
+    year: number;
+    principal: number;
+    interest: number;
+    balance: number;
+}
+export interface MortgageInput {
+    propertyPrice: number;
+    downPayment: number;
+    annualInterestRate: number;
+    amortizationYears: number;
+}
+export interface MortgageOutput {
+    loanAmount: number;
+    totalMortgage: number;
+    monthlyPayment: number;
+    totalInterestPaid: number;
+    totalPaid: number;
+    landTransferTax: number;
+    notaryFees: number;
+    registrationFees: number;
+    amortizationSchedule: AmortizationScheduleItem[];
+    otherFees: OtherFees;
+}

package/dist/types/mortgage/uk/UKMortgageService.d.ts

@@ -0,0 +1,4 @@
+import { MortgageInput, MortgageOutput, MortgageRules } from "./domain/types";
+export interface UKMortgageService {
+    calculate(input: MortgageInput, rules: MortgageRules): MortgageOutput;
+}

package/dist/types/mortgage/uk/UKMortgageServiceImpl.d.ts

@@ -0,0 +1,9 @@
+import { UKMortgageService } from "./UKMortgageService";
+import { MortgageInput, MortgageOutput, MortgageRules } from "./domain/types";
+export declare class UKMortgageServiceImpl implements UKMortgageService {
+    calculate(input: MortgageInput, rules: MortgageRules): MortgageOutput;
+    private calculateStampDuty;
+    private applyStampDutyBrackets;
+    private calculateAmortizationSchedule;
+    private calculatePayment;
+}

package/dist/types/mortgage/uk/domain/types.d.ts

@@ -0,0 +1,49 @@
+import { OtherFees } from "../../domain/types";
+export interface MortgageRules {
+    loanConstraints: LoanConstraints;
+    interest: InterestRules;
+    stampDuty: StampDutyRules;
+}
+export interface LoanConstraints {
+    maxLtvPercent: number;
+    maxAmortizationYears: number;
+}
+export interface InterestRules {
+    compounding: 'MONTHLY';
+}
+export interface StampDutyBracket {
+    upTo?: number;
+    above?: number;
+    rate: number;
+}
+export interface StampDutyRules {
+    standardBrackets: StampDutyBracket[];
+    firstTimeBuyer: FirstTimeBuyerStampDuty;
+}
+export interface FirstTimeBuyerStampDuty {
+    brackets: StampDutyBracket[];
+    maxEligiblePropertyPrice: number;
+}
+export interface AmortizationScheduleItem {
+    year: number;
+    principal: number;
+    interest: number;
+    balance: number;
+}
+export interface MortgageInput {
+    propertyPrice: number;
+    downPayment: number;
+    annualInterestRate: number;
+    amortizationYears: number;
+    isFirstTimeBuyer: boolean;
+}
+export interface MortgageOutput {
+    loanAmount: number;
+    totalMortgage: number;
+    monthlyPayment: number;
+    totalInterestPaid: number;
+    totalPaid: number;
+    stampDuty: number;
+    amortizationSchedule: AmortizationScheduleItem[];
+    otherFees: OtherFees;
+}

package/dist/types/mortgage/usa/USAMortgageService.d.ts

@@ -0,0 +1,4 @@
+import { MortgageInput, MortgageOutput, MortgageRules } from "./domain/types";
+export interface USAMortgageService {
+    calculate(input: MortgageInput, rules: MortgageRules): MortgageOutput;
+}

package/dist/types/mortgage/usa/USAMortgageServiceImpl.d.ts

@@ -0,0 +1,8 @@
+import { USAMortgageService } from "./USAMortgageService";
+import { MortgageInput, MortgageOutput, MortgageRules } from "./domain/types";
+export declare class USAMortgageServiceImpl implements USAMortgageService {
+    calculate(input: MortgageInput, rules: MortgageRules): MortgageOutput;
+    private calculateTransferTax;
+    private calculateAmortizationSchedule;
+    private calculatePayment;
+}

package/dist/types/mortgage/usa/domain/types.d.ts

@@ -0,0 +1,44 @@
+import { OtherFees } from "../../domain/types";
+export interface MortgageRules {
+    loanConstraints: LoanConstraints;
+    interest: InterestRules;
+    transferTax: TransferTaxRules;
+}
+export interface LoanConstraints {
+    maxLtvPercent: number;
+    maxAmortizationYears: number;
+}
+export interface InterestRules {
+    compounding: 'MONTHLY';
+}
+export interface TransferTaxBracket {
+    upTo?: number;
+    above?: number;
+    rate: number;
+}
+export interface TransferTaxRules {
+    brackets: TransferTaxBracket[];
+}
+export interface AmortizationScheduleItem {
+    year: number;
+    principal: number;
+    interest: number;
+    balance: number;
+}
+export interface MortgageInput {
+    propertyPrice: number;
+    downPayment: number;
+    annualInterestRate: number;
+    amortizationYears: number;
+    isFirstTimeBuyer: boolean;
+}
+export interface MortgageOutput {
+    loanAmount: number;
+    totalMortgage: number;
+    monthlyPayment: number;
+    totalInterestPaid: number;
+    totalPaid: number;
+    transferTax: number;
+    amortizationSchedule: AmortizationScheduleItem[];
+    otherFees: OtherFees;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@novha/calc-engines",
-  "version": "2.0.3",
+  "version": "4.0.0",
   "main": "dist/index.js",
   "types": "dist/types/index.d.ts",
   "scripts": {

package/src/corporate/germany/GermanyCorporateTaxService.ts

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

package/src/corporate/germany/GermanyCorporateTaxServiceImpl.ts

@@ -0,0 +1,64 @@
+import { Breakdown } from "../domain/types";
+import { GermanyCorporateTaxService } from "./GermanyCorporateTaxService";
+import { Input, Result, Rules } from "./domain/types";
+
+export class GermanyCorporateTaxServiceImpl implements GermanyCorporateTaxService {
+    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,
+                solidaritySurcharge: 0,
+                tradeTax: 0,
+                totalTax: 0,
+                effectiveTaxRate: 0,
+                breakdowns: [],
+            };
+        }
+
+        const corporateTax = income * this._rules.corporateIncomeTax.rate;
+        const solidaritySurcharge = corporateTax * this._rules.solidaritySurcharge.rate;
+        const tradeTax =
+            income * this._rules.tradeTax.multiplier * this._rules.tradeTax.assessmentRate;
+        const totalTax = corporateTax + solidaritySurcharge + tradeTax;
+
+        const breakdowns: Breakdown[] = [
+            {
+                from: '0',
+                to: 'All',
+                rate: this._rules.corporateIncomeTax.rate,
+                amount: corporateTax,
+            },
+            {
+                from: 'Corp Tax',
+                to: 'Solidarity',
+                rate: this._rules.solidaritySurcharge.rate,
+                amount: solidaritySurcharge,
+            },
+            {
+                from: '0',
+                to: 'Trade',
+                rate: this._rules.tradeTax.multiplier * this._rules.tradeTax.assessmentRate,
+                amount: tradeTax,
+            },
+        ];
+
+        return {
+            corporateTax,
+            solidaritySurcharge,
+            tradeTax,
+            totalTax,
+            effectiveTaxRate: (totalTax / income) * 100,
+            breakdowns,
+        };
+    }
+}

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

@@ -0,0 +1,20 @@
+import { Breakdown } from "../../domain/types";
+
+export interface Rules {
+    corporateIncomeTax: { rate: number };
+    solidaritySurcharge: { rate: number };
+    tradeTax: { multiplier: number; assessmentRate: number };
+}
+
+export interface Input {
+    taxableIncome: number;
+}
+
+export interface Result {
+    corporateTax: number;
+    solidaritySurcharge: number;
+    tradeTax: number;
+    totalTax: number;
+    effectiveTaxRate: number;
+    breakdowns: Breakdown[];
+}

package/src/corporate/uk/UKCorporateTaxService.ts

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

package/src/corporate/uk/UKCorporateTaxServiceImpl.ts

@@ -0,0 +1,82 @@
+import { Breakdown } from "../domain/types";
+import { UKCorporateTaxService } from "./UKCorporateTaxService";
+import { Input, MarginalReliefRule, Result, Rules } from "./domain/types";
+
+export class UKCorporateTaxServiceImpl implements UKCorporateTaxService {
+    private _input: Input;
+    private _rules: Rules;
+
+    constructor(input: Input, rules: Rules) {
+        this._input = input;
+        this._rules = rules;
+    }
+
+    calculate(): Result {
+        const income = this._input.taxableIncome;
+        const { smallProfits, main, marginalRelief } = this._rules.regimes;
+
+        let tax = 0;
+        let breakdowns: Breakdown[] = [];
+
+        if (income <= 0) {
+            return { corporateTax: 0, effectiveTaxRate: 0, breakdowns: [] };
+        }
+
+        if (income <= marginalRelief.lowerLimit) {
+            tax = income * smallProfits.rate;
+            breakdowns = [{
+                from: '0',
+                to: `${marginalRelief.lowerLimit}`,
+                rate: smallProfits.rate,
+                amount: tax,
+            }];
+        } else if (income >= marginalRelief.upperLimit) {
+            tax = income * main.rate;
+            breakdowns = [{
+                from: '0',
+                to: 'Above',
+                rate: main.rate,
+                amount: tax,
+            }];
+        } else {
+            tax = this.applyMarginalRelief(income, marginalRelief);
+            breakdowns = this.buildMarginalReliefBreakdowns(income, tax, marginalRelief);
+        }
+
+        return {
+            corporateTax: tax,
+            effectiveTaxRate: income > 0 ? (tax / income) * 100 : 0,
+            breakdowns,
+        };
+    }
+
+    private applyMarginalRelief(income: number, rules: MarginalReliefRule): number {
+        const grossTax = income * rules.mainRate;
+        const relief = rules.standardFraction * (rules.upperLimit - income);
+        return grossTax - relief;
+    }
+
+    private buildMarginalReliefBreakdowns(
+        income: number,
+        tax: number,
+        rules: MarginalReliefRule,
+    ): Breakdown[] {
+        const grossTax = income * rules.mainRate;
+        const relief = rules.standardFraction * (rules.upperLimit - income);
+
+        return [
+            {
+                from: '0',
+                to: 'Above',
+                rate: rules.mainRate,
+                amount: grossTax,
+            },
+            {
+                from: `${rules.lowerLimit}`,
+                to: `${rules.upperLimit}`,
+                rate: -(rules.standardFraction),
+                amount: -relief,
+            },
+        ];
+    }
+}

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

@@ -0,0 +1,38 @@
+import { Breakdown } from "../../domain/types";
+
+export interface FlatTaxRule {
+    type: 'flat';
+    rate: number;
+    conditions?: {
+        maxIncome?: number;
+    };
+}
+
+export interface MarginalReliefRule {
+    type: 'marginal_relief';
+    mainRate: number;
+    smallProfitsRate: number;
+    upperLimit: number;
+    lowerLimit: number;
+    standardFraction: number;
+}
+
+export type TaxRule = FlatTaxRule | MarginalReliefRule;
+
+export interface Rules {
+    regimes: {
+        smallProfits: FlatTaxRule;
+        main: FlatTaxRule;
+        marginalRelief: MarginalReliefRule;
+    };
+}
+
+export interface Input {
+    taxableIncome: number;
+}
+
+export interface Result {
+    corporateTax: number;
+    effectiveTaxRate: number;
+    breakdowns: Breakdown[];
+}

package/src/corporate/usa/USACorporateTaxService.ts

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

package/src/corporate/usa/USACorporateTaxServiceImpl.ts

@@ -0,0 +1,35 @@
+import { Breakdown } from "../domain/types";
+import { USACorporateTaxService } from "./USACorporateTaxService";
+import { Input, Result, Rules } from "./domain/types";
+
+export class USACorporateTaxServiceImpl implements USACorporateTaxService {
+    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/usa/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/income-tax/germany/GermanyIncomeTaxService.ts

@@ -0,0 +1,5 @@
+import { ComputedIncomeTaxValues } from "./domain/types";
+
+export interface GermanyIncomeTaxService {
+    calculateNetIncome(): ComputedIncomeTaxValues;
+}