moneyfunx 0.0.30 → 0.0.33

package/build/index.d.ts

@@ -0,0 +1,6 @@
+export { PaymentTooLowError } from "./lib/errors";
+export { calculateMinPayment, numPaymentsToZero, principalRemaining, } from "./lib/helperFunctions";
+export { ILoan, Loan } from "./lib/loan";
+export { determineExtraPayment, amortizePayments, payLoans, } from "./lib/payments";
+export { AmortizationRecord, LoansPaymentSummary, PaymentSummary, } from "./lib/paymentTypes";
+export { snowball, avalanche, sortLoans } from "./lib/sorting";

package/build/index.js

@@ -0,0 +1,5 @@
+export { PaymentTooLowError } from "./lib/errors";
+export { calculateMinPayment, numPaymentsToZero, principalRemaining, } from "./lib/helperFunctions";
+export { Loan } from "./lib/loan";
+export { determineExtraPayment, amortizePayments, payLoans, } from "./lib/payments";
+export { snowball, avalanche, sortLoans } from "./lib/sorting";

package/build/lib/errors.d.ts

@@ -0,0 +1,6 @@
+export declare class NegativeBalanceError extends Error {
+    constructor(message: string);
+}
+export declare class PaymentTooLowError extends Error {
+    constructor(message: string);
+}

package/build/lib/errors.js

@@ -0,0 +1,14 @@
+export class NegativeBalanceError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, NegativeBalanceError.prototype);
+        this.name = "NegativeBalanceError";
+    }
+}
+export class PaymentTooLowError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, PaymentTooLowError.prototype);
+        this.name = "PaymentTooLowError";
+    }
+}

package/build/lib/helperFunctions.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Helper Functions
+ *
+ * These functions are inner primitives used in lifecycle calculations for Loans
+ */
+/**
+ * Calculates the minimum payment to pay the principal back in the number of periods at the periodic rate
+ *
+ * balance = principal + interest
+ *
+ * @param {number} principal The amount borrowed
+ * @param {number} periodicRate The rate the balance accrues interest at per period
+ * @param {number [int]} periods The number of periods the principal is repaid over
+ * @returns {number} The minimum payment
+ */
+export declare function calculateMinPayment(principal: number, periodicRate: number, periods: number): number;
+/**
+ * Calculates the principal remaining after a certain number of payments from a beginning principal at a periodic rate
+ *
+ * balance = principal + interest
+ *
+ * @param {number} principal The amount borrowed
+ * @param {number} payment The amount paid at each period
+ * @param {number} periodicRate The rate the balance accrues interest at per period
+ * @param {number [int]} periods The number of periods paid to compute the desired principal remaining
+ * @returns  {number} The remaining principal
+ */
+export declare function principalRemaining(principal: number, payment: number, periodicRate: number, periods: number): number;
+/**
+ * Calculates the number of payments required to pay off a principal
+ *
+ * balance = principal + interest
+ *
+ * @param {number} principal The amount borrowed
+ * @param {number} payment The amount paid at each period
+ * @param {number} periodicRate The rate the balance accrues interest at per period
+ * @returns The number of payments needed to pay off the principal
+ */
+export declare function numPaymentsToZero(principal: number, payment: number, periodicRate: number): number;

package/build/lib/helperFunctions.js

@@ -0,0 +1,51 @@
+/**
+ * Helper Functions
+ *
+ * These functions are inner primitives used in lifecycle calculations for Loans
+ */
+/**
+ * Calculates the minimum payment to pay the principal back in the number of periods at the periodic rate
+ *
+ * balance = principal + interest
+ *
+ * @param {number} principal The amount borrowed
+ * @param {number} periodicRate The rate the balance accrues interest at per period
+ * @param {number [int]} periods The number of periods the principal is repaid over
+ * @returns {number} The minimum payment
+ */
+export function calculateMinPayment(principal, periodicRate, periods) {
+    return periodicRate > 0
+        ? principal *
+            ((periodicRate * Math.pow((1 + periodicRate), periods)) /
+                (Math.pow((1 + periodicRate), periods) - 1))
+        : principal / periods;
+}
+/**
+ * Calculates the principal remaining after a certain number of payments from a beginning principal at a periodic rate
+ *
+ * balance = principal + interest
+ *
+ * @param {number} principal The amount borrowed
+ * @param {number} payment The amount paid at each period
+ * @param {number} periodicRate The rate the balance accrues interest at per period
+ * @param {number [int]} periods The number of periods paid to compute the desired principal remaining
+ * @returns  {number} The remaining principal
+ */
+export function principalRemaining(principal, payment, periodicRate, periods) {
+    return Math.max(principal * Math.pow((1 + periodicRate), periods) -
+        payment * ((Math.pow((1 + periodicRate), periods) - 1) / periodicRate), 0);
+}
+/**
+ * Calculates the number of payments required to pay off a principal
+ *
+ * balance = principal + interest
+ *
+ * @param {number} principal The amount borrowed
+ * @param {number} payment The amount paid at each period
+ * @param {number} periodicRate The rate the balance accrues interest at per period
+ * @returns The number of payments needed to pay off the principal
+ */
+export function numPaymentsToZero(principal, payment, periodicRate) {
+    return Math.ceil(Math.log(payment / (payment - principal * periodicRate)) /
+        Math.log(periodicRate + 1));
+}

package/build/lib/loan.d.ts

@@ -0,0 +1,86 @@
+/**
+ *
+ * *****************
+ * *** MoneyFunx ***
+ * *****************
+ *
+ * mek it funx up
+ *
+ * This library contains functions used to in personal financial analysis
+ *
+ */
+/**
+ * Represents a financial loan
+ */
+export interface ILoan {
+    id: string;
+    principal: number;
+    annualRate: number;
+    periodsPerYear: number;
+    termInYears: number;
+    periodicRate: number;
+    periods: number;
+    minPayment: number;
+    totalInterest: number;
+}
+export declare class Loan implements ILoan {
+    id: string;
+    principal: number;
+    annualRate: number;
+    periodsPerYear: number;
+    termInYears: number;
+    periodicRate: number;
+    periods: number;
+    minPayment: number;
+    totalInterest: number;
+    /**
+     * @constructor
+     * @param {number} principal The amount borrowed
+     * @param {number} annualRate The yearly rate the loan accrues interest at
+     * @param {number} periodsPerYear The number of times the interest is accrued in a year
+     * @param {number} termInYears The number of years the loan is repaid over
+     */
+    constructor(principal: number, annualRate: number, periodsPerYear: number, termInYears: number);
+    /**
+     * Verifies a payment amount is valid
+     * Throws a PaymentTooLowError if the payment amount is less than the loan's minimum payment
+     *
+     * @param {number} payment The amount to pay the loan with
+     * @returns {number} The validated payment amount
+     */
+    validatePayment(payment?: number): number;
+    /**
+     * Calculates the minimum payment to pay off the loan in the required number of periods
+     * @returns {number} The minimum amount to pay off the loan in the required number of periods
+     */
+    calculateMinPayment(): number;
+    /**
+     * Calculates the amount of interest accrued in a period on a provided balance
+     * @param {number} balance The amunt of money owed on a loan
+     * @returns {number} The amount of interest accrued in one period
+     */
+    accrueInterest(balance?: number): number;
+    /**
+     * Calculates the number of payments needed to pay off a balance at a provided payemnt amount
+     * @param {number} payment The amount to pay the loan with
+     * @param {number} balance The amout of money owed on a loan
+     * @returns {number} The number of payments neede to pay the loan off
+     */
+    numPaymentsToZero(payment?: number, balance?: number): number;
+    /**
+     * Calculates the amout of pricipal remaining after paying a starting balance with a payment for a number of periods
+     * @param {number} periods The number of payemnts to make
+     * @param {number} payment The amount to pay the loan with
+     * @param {number} balance The amount of money owed on a loan
+     * @returns {number} The share of the amount borrowed left to pay
+     */
+    principalRemaining(periods: number, payment?: number, balance?: number): number;
+    /**
+     * Calculates the amount of interest paid after paying a starting balance with a payment for a number of periods
+     * @param {number} periods The number of payments to make
+     * @param {number} payment The amount to pay the loan with
+     * @param {number} balance The amount of money owed on a loan
+     * @returns The total amount of interest paid
+     */
+    interestPaid(periods: number, payment?: number, balance?: number): number;
+}

package/{src → build}/lib/loan.js

@@ -9,74 +9,8 @@
  * This library contains functions used to in personal financial analysis
  *
  */
-
 import * as errors from "./errors";
-
-/**
- * Calculates the minimum payment to pay the principal back in the number of periods at the periodic rate
- *
- * balance = principal + interest
- *
- * @param {number} principal The amount borrowed
- * @param {number} periodicRate The rate the balance accrues interest at per period
- * @param {number [int]} periods The number of periods the principal is repaid over
- * @returns {number} The minimum payment
- */
-export function calculateMinPayment(principal, periodicRate, periods) {
-    return periodicRate > 0 ?
-        principal * (
-            (
-                periodicRate * (1 + periodicRate) ** periods
-            ) / (
-                (1 + periodicRate) ** periods - 1
-            )
-        ) :
-        principal / periods;
-}
-
-/**
- * Calculates the principal remaining after a certain number of payments from a beginning principal at a periodic rate
- *
- * balance = principal + interest
- *
- * @param {number} principal The amount borrowed
- * @param {number} payment The amount paid at each period
- * @param {number} periodicRate The rate the balance accrues interest at per period
- * @param {number [int]} periods The number of periods paid to compute the desired principal remaining
- * @returns  {number} The remaining principal
- */
-export function principalRemaining(principal, payment, periodicRate, periods) {
-    return Math.max(
-        (principal * (1 + periodicRate) ** periods) - (
-            payment * (
-                ((1 + periodicRate) ** periods - 1) / (periodicRate)
-            )
-        ),
-        0
-    );
-}
-
-/**
- * Calculates the number of payments required to pay off a principal
- *
- * balance = principal + interest
- *
- * @param {number} principal The amount borrowed
- * @param {number} payment The amount paid at each period
- * @param {number} periodicRate The rate the balance accrues interest at per period
- * @returns The number of payments needed to pay off the principal
- */
-export function numPaymentsToZero(principal, payment, periodicRate) {
-    return Math.ceil(
-        Math.log(
-            (payment / (payment - principal * periodicRate))
-        ) / Math.log(periodicRate + 1)
-    );
-}
-
-/**
- * Represents a financial loan
-*/
+import * as helpers from "./helperFunctions";
 export class Loan {
     /**
      * @constructor
@@ -94,9 +28,8 @@ export class Loan {
         this.periodicRate = this.annualRate / this.periodsPerYear;
         this.periods = this.periodsPerYear * this.termInYears;
         this.minPayment = this.calculateMinPayment();
-        this.totalInterest = (this.minPayment * (this.periods)) - this.principal;
+        this.totalInterest = this.minPayment * this.periods - this.principal;
     }
-
     /**
      * Verifies a payment amount is valid
      * Throws a PaymentTooLowError if the payment amount is less than the loan's minimum payment
@@ -107,19 +40,18 @@ export class Loan {
     validatePayment(payment = this.minPayment) {
         if (payment < this.minPayment) {
             throw new errors.PaymentTooLowError(`payment of ${payment} cannot be less than ${this.minPayment}`);
-        } else {
+        }
+        else {
             return payment;
         }
     }
-
     /**
      * Calculates the minimum payment to pay off the loan in the required number of periods
      * @returns {number} The minimum amount to pay off the loan in the required number of periods
      */
     calculateMinPayment() {
-        return calculateMinPayment(this.principal, this.periodicRate, this.periods);
+        return helpers.calculateMinPayment(this.principal, this.periodicRate, this.periods);
     }
-
     /**
      * Calculates the amount of interest accrued in a period on a provided balance
      * @param {number} balance The amunt of money owed on a loan
@@ -128,7 +60,6 @@ export class Loan {
     accrueInterest(balance = this.principal) {
         return balance * this.periodicRate;
     }
-
     /**
      * Calculates the number of payments needed to pay off a balance at a provided payemnt amount
      * @param {number} payment The amount to pay the loan with
@@ -136,14 +67,9 @@ export class Loan {
      * @returns {number} The number of payments neede to pay the loan off
      */
     numPaymentsToZero(payment = this.minPayment, balance = this.principal) {
-        payment = this.validatePayment(payment);
-        return numPaymentsToZero(
-            balance,
-            payment,
-            this.periodicRate
-        );
+        this.validatePayment(payment);
+        return helpers.numPaymentsToZero(balance, payment, this.periodicRate);
     }
-
     /**
      * Calculates the amout of pricipal remaining after paying a starting balance with a payment for a number of periods
      * @param {number} periods The number of payemnts to make
@@ -152,17 +78,11 @@ export class Loan {
      * @returns {number} The share of the amount borrowed left to pay
      */
     principalRemaining(periods, payment = this.minPayment, balance = this.principal) {
-        payment = this.validatePayment(payment);
-        return periods < this.numPaymentsToZero(payment, balance) ?
-            principalRemaining(
-                balance,
-                payment,
-                this.periodicRate,
-                periods
-            ) :
-            0;
+        this.validatePayment(payment);
+        return periods < this.numPaymentsToZero(payment, balance)
+            ? helpers.principalRemaining(balance, payment, this.periodicRate, periods)
+            : 0;
     }
-
     /**
      * Calculates the amount of interest paid after paying a starting balance with a payment for a number of periods
      * @param {number} periods The number of payments to make
@@ -171,26 +91,13 @@ export class Loan {
      * @returns The total amount of interest paid
      */
     interestPaid(periods, payment = this.minPayment, balance = this.principal) {
-        payment = this.validatePayment(payment);
-        return periods < this.numPaymentsToZero(payment, balance) ?
-            (payment * periods) - (balance - this.principalRemaining(periods, payment, balance)) :
-            Math.max(
-                payment * (this.numPaymentsToZero(payment, balance) - 1) - (
-                    balance - this.principalRemaining(
-                        this.numPaymentsToZero(payment) - 1,
-                        payment,
-                        balance
-                    )
-                ) + (
-                    this.accrueInterest(
-                        this.principalRemaining(
-                            this.numPaymentsToZero(payment) - 1,
-                            payment,
-                            balance
-                        )
-                    )
-                ),
-                0
-            );
+        this.validatePayment(payment);
+        return periods < this.numPaymentsToZero(payment, balance)
+            ? payment * periods -
+                (balance - this.principalRemaining(periods, payment, balance))
+            : Math.max(payment * (this.numPaymentsToZero(payment, balance) - 1) -
+                (balance -
+                    this.principalRemaining(this.numPaymentsToZero(payment) - 1, payment, balance)) +
+                this.accrueInterest(this.principalRemaining(this.numPaymentsToZero(payment) - 1, payment, balance)), 0);
     }
 }

package/build/lib/paymentTypes.d.ts

@@ -0,0 +1,13 @@
+export interface AmortizationRecord {
+    period: number;
+    principal: number;
+    interest: number;
+    principalRemaining: number;
+}
+export interface PaymentSummary {
+    lifetimeInterest: number;
+    amortizationSchedule: Array<AmortizationRecord>;
+}
+export interface LoansPaymentSummary {
+    [id: string]: PaymentSummary;
+}

package/build/lib/paymentTypes.js

@@ -0,0 +1 @@
+export {};

package/build/lib/payments.d.ts

@@ -0,0 +1,38 @@
+/**
+ *
+ * This file contains functions for computing detailed information on paying loans
+ *
+ */
+import { ILoan, Loan } from "./loan";
+import { AmortizationRecord, LoansPaymentSummary } from "./paymentTypes";
+/**
+ *
+ * Calculates the extra amount in a payment after all loans' minimum payments are met
+ * Throws an exception if the payment provided is less than the collective minimum payments for all loans
+ *
+ * @param {Array<Loan>} loans The loans to allocate minimum payments
+ * @param {number} payment The amount to pay across all loans
+ * @returns {number} The extra amount of payment
+ */
+export declare function determineExtraPayment(loans: Array<ILoan>, payment: number): number;
+/**
+ *
+ * Calculates the amortization schedule for a loan paid with a payment
+ *
+ * @param {Loan} loan The loan to amortize payments for
+ * @param {number} payment The amount to pay to the loan's balance each period
+ * @param {number} numPayments The number of periods to make payments to the loan
+ * @param {number} startPeriod An initial offset of periods to "fast-forward" the state of the loan to prior to calculation of each period
+ * @returns {Array<AmortizationRecord>} The amortization schdule for the number of payments of payment made to the loan from the provided start period
+ */
+export declare function amortizePayments(loan: Loan, payment: number, numPayments: number, startPeriod?: number): Array<AmortizationRecord>;
+/**
+ *
+ * Calculates a wealth of information about paying of a set of loans with a total payment amount
+ *
+ * @param {Array<Loans>} loans The loans to pay off
+ * @param {number} payment The total amount of money budgeted to pay all loans each period
+ * @param {boolean} reduceMinimum Flag to reduce the total payment amount by a loan's minimum when that loan is paid off
+ * @returns {LoansPaymentSummary} Various totals and series of data regarding paying off the loans at the payment amount
+ */
+export declare function payLoans(loans: Array<Loan>, payment: number, reduceMinimum?: boolean): LoansPaymentSummary;

package/{src → build}/lib/payments.js

@@ -3,10 +3,8 @@
  * This file contains functions for computing detailed information on paying loans
  *
  */
-
 import * as errors from "./errors";
-import * as loanLib from "./loan";
-
+import * as helpers from "./helperFunctions";
 /**
  *
  * Calculates the extra amount in a payment after all loans' minimum payments are met
@@ -17,16 +15,12 @@ import * as loanLib from "./loan";
  * @returns {number} The extra amount of payment
  */
 export function determineExtraPayment(loans, payment) {
-    const totalMinPayment = loans.reduce(
-        (previousValue, currentValue) => previousValue + currentValue.minPayment,
-        0
-    );
+    const totalMinPayment = loans.reduce((previousValue, currentValue) => previousValue + currentValue.minPayment, 0);
     if (totalMinPayment > payment) {
         throw new errors.PaymentTooLowError(`Payment amount of ${payment} must be greater than ${totalMinPayment}`);
     }
     return payment - totalMinPayment;
 }
-
 /**
  *
  * Calculates the amortization schedule for a loan paid with a payment
@@ -35,56 +29,30 @@ export function determineExtraPayment(loans, payment) {
  * @param {number} payment The amount to pay to the loan's balance each period
  * @param {number} numPayments The number of periods to make payments to the loan
  * @param {number} startPeriod An initial offset of periods to "fast-forward" the state of the loan to prior to calculation of each period
- * @returns {Array<JSON[number, number, number, number]>} The amortization schdule for the number of payments of payment made to the loan from the provided start period
+ * @returns {Array<AmortizationRecord>} The amortization schdule for the number of payments of payment made to the loan from the provided start period
  */
-export function amortizePayments(loan, payment = null, numPayments = null, startPeriod = 0) {
+export function amortizePayments(loan, payment, numPayments, startPeriod = 0) {
     if (payment === null) {
         payment = loan.minPayment;
     }
     payment = loan.validatePayment(payment);
-
     if (numPayments === null) {
         numPayments = loan.numPaymentsToZero(payment);
     }
-
     let amortizationSchedule = [];
-    for (
-        let period = 0;
-        period < numPayments;
-        period++
-    ) {
-        let interestThisPeriod = loan.accrueInterest(
-            loan.principalRemaining(
-                period,
-                payment,
-                loan.principalRemaining(startPeriod)
-            )
-        );
-        let principalThisPeriod = Math.min(
-            payment - interestThisPeriod,
-            loan.principalRemaining(
-                period,
-                payment,
-                loan.principalRemaining(startPeriod)
-            )
-        );
-        let principalRemaining = loan.principalRemaining(
-            period + 1,
-            payment,
-            loan.principalRemaining(startPeriod)
-        );
-        amortizationSchedule.push(
-            {
-                period: startPeriod + period + 1,
-                principal: principalThisPeriod,
-                interest: interestThisPeriod,
-                principalRemaining: principalRemaining,
-            }
-        );
+    for (let period = 0; period < numPayments; period++) {
+        let interestThisPeriod = loan.accrueInterest(loan.principalRemaining(period, payment, loan.principalRemaining(startPeriod)));
+        let principalThisPeriod = Math.min(payment - interestThisPeriod, loan.principalRemaining(period, payment, loan.principalRemaining(startPeriod)));
+        let principalRemaining = loan.principalRemaining(period + 1, payment, loan.principalRemaining(startPeriod));
+        amortizationSchedule.push({
+            period: startPeriod + period + 1,
+            principal: principalThisPeriod,
+            interest: interestThisPeriod,
+            principalRemaining: principalRemaining,
+        });
     }
     return amortizationSchedule;
 }
-
 /**
  *
  * Calculates a wealth of information about paying of a set of loans with a total payment amount
@@ -97,84 +65,61 @@ export function amortizePayments(loan, payment = null, numPayments = null, start
 export function payLoans(loans, payment, reduceMinimum = false) {
     let monthlyPayment = payment;
     let paymentData = {};
-    loans.map(
-        (loan) => {
-            paymentData[loan.id] = { lifetimeInterest: 0, amortizationSchedule: [] };
-        }
-    );
-
+    loans.map((loan) => {
+        paymentData[loan.id] = { lifetimeInterest: 0, amortizationSchedule: [] };
+    });
     let periodsElapsed = 0;
     let paidLoans = 0;
     let lifetimeInterest = 0;
     let totalAmortizationSchedule = [];
-
     while (paidLoans < loans.length) {
         let firstLoan = loans.slice(paidLoans)[0];
-        let firstLoanPayment = firstLoan.minPayment + determineExtraPayment(loans.slice(paidLoans), monthlyPayment);
-        let periodsToPay = loanLib.numPaymentsToZero(
-            firstLoan.principalRemaining(periodsElapsed),
-            firstLoanPayment,
-            firstLoan.periodicRate
-        );
-        let firstLoanInterestPaid = firstLoan.interestPaid(
-            periodsToPay,
-            firstLoanPayment,
-            firstLoan.principalRemaining(periodsElapsed)
-        );
+        let firstLoanPayment = firstLoan.minPayment +
+            determineExtraPayment(loans.slice(paidLoans), monthlyPayment);
+        let periodsToPay = helpers.numPaymentsToZero(firstLoan.principalRemaining(periodsElapsed), firstLoanPayment, firstLoan.periodicRate);
+        let firstLoanInterestPaid = firstLoan.interestPaid(periodsToPay, firstLoanPayment, firstLoan.principalRemaining(periodsElapsed));
         let firstLoanPaidPeriods = amortizePayments(firstLoan, firstLoanPayment, periodsToPay, periodsElapsed);
-
         paymentData[firstLoan.id].lifetimeInterest += firstLoanInterestPaid;
         paymentData[firstLoan.id].amortizationSchedule = [
             ...paymentData[firstLoan.id].amortizationSchedule,
-            ...firstLoanPaidPeriods
+            ...firstLoanPaidPeriods,
         ];
-
         totalAmortizationSchedule = [
             ...totalAmortizationSchedule,
-            ...firstLoanPaidPeriods
+            ...firstLoanPaidPeriods,
         ];
-
         // the first loan is paid off, handle totals
         paidLoans += 1;
         lifetimeInterest += paymentData[firstLoan.id].lifetimeInterest;
         if (reduceMinimum) {
             monthlyPayment -= firstLoan.minPayment;
         }
-
         // handle calculating information for the rest of the loans
         loans.slice(paidLoans).map((loan) => {
-            paymentData[loan.id].lifetimeInterest += loan.interestPaid(
-                periodsToPay,
-                loan.minPayment,
-                loan.principalRemaining(periodsElapsed)
-            );
+            paymentData[loan.id].lifetimeInterest += loan.interestPaid(periodsToPay, loan.minPayment, loan.principalRemaining(periodsElapsed));
             let paidPeriods = amortizePayments(loan, loan.minPayment, periodsToPay, periodsElapsed);
             paymentData[loan.id].amortizationSchedule = [
                 ...paymentData[loan.id].amortizationSchedule,
-                ...paidPeriods
+                ...paidPeriods,
             ];
-
             totalAmortizationSchedule = totalAmortizationSchedule.map((element) => {
                 const matchedInnerElement = paidPeriods.find((innerElement) => innerElement.period === element.period);
-                return matchedInnerElement ?
-                    {
+                return matchedInnerElement
+                    ? {
                         period: element.period,
                         principal: element.principal + matchedInnerElement.principal,
                         interest: element.interest + matchedInnerElement.interest,
-                        principalRemaining: element.principalRemaining + matchedInnerElement.principalRemaining
-                    } :
-                    element;
+                        principalRemaining: element.principalRemaining +
+                            matchedInnerElement.principalRemaining,
+                    }
+                    : element;
             });
         });
         periodsElapsed += periodsToPay;
     }
-
-    if (loans.length) {
-        paymentData["totals"] = {
-            lifetimeInterest: lifetimeInterest,
-            amortizationSchedule: totalAmortizationSchedule
-        };
-    }
-
+    paymentData["totals"] = {
+        lifetimeInterest: lifetimeInterest,
+        amortizationSchedule: totalAmortizationSchedule,
+    };
     return paymentData;
 }