moneyfunx 1.2.3 → 1.2.5

package/build/lib/helperFunctions.d.ts

@@ -6,10 +6,8 @@
 /**
  * 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} periodicRate The rate the principal accrues interest at per period
  * @param {number [int]} periods The number of periods the principal is repaid over
  * @returns {number} The minimum payment
  */
@@ -17,11 +15,9 @@ export declare function calculateMinPayment(principal: number, periodicRate: num
 /**
  * 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} periodicRate The rate the princpal 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
  */
@@ -29,11 +25,9 @@ export declare function principalRemaining(principal: number, payment: number, p
 /**
  * Calculates the total interest paid 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} periodicRate The rate the princpal accrues interest at per period
  * @param {number [int]} periods The number of periods paid to compute the desired principal remaining
  * @returns  {number} The total interest paid
  */
@@ -41,11 +35,9 @@ export declare function interestPaid(principal: number, payment: number, periodi
 /**
  * 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
+ * @param {number} periodicRate The rate the princpal 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

@@ -6,10 +6,8 @@
 /**
  * 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} periodicRate The rate the principal accrues interest at per period
  * @param {number [int]} periods The number of periods the principal is repaid over
  * @returns {number} The minimum payment
  */
@@ -23,26 +21,22 @@ export function calculateMinPayment(principal, periodicRate, 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} periodicRate The rate the princpal 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);
+    return Math.max((principal * Math.pow((1 + periodicRate), periods)) -
+        (payment * (Math.pow((1 + periodicRate), periods) - 1) / periodicRate), 0);
 }
 /**
  * Calculates the total interest paid 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} periodicRate The rate the princpal accrues interest at per period
  * @param {number [int]} periods The number of periods paid to compute the desired principal remaining
  * @returns  {number} The total interest paid
  */
@@ -53,11 +47,9 @@ export function interestPaid(principal, payment, periodicRate, periods) {
 /**
  * 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
+ * @param {number} periodicRate The rate the princpal accrues interest at per period
  * @returns The number of payments needed to pay off the principal
  */
 export function numPaymentsToZero(principal, payment, periodicRate) {

package/build/lib/payments.d.ts

@@ -10,7 +10,7 @@ import type { AmortizationRecord, LoansPaymentSchedule } 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 {ILoan[]} loans The loans to allocate minimum payments
  * @param {number} payment The amount to pay across all loans
  * @returns {number} The extra amount of payment
  */
@@ -25,14 +25,14 @@ export declare function determineExtraPayment(loans: ILoan[], payment: number):
  * @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
  * @param {number} carryover An additional amount to pay towards a loan, used when a residual amount is available from paying off the previous loan this period
- * @returns {Array<AmortizationRecord>} The amortization schdule for the number of payments of payment made to the loan from the provided start period
+ * @returns {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, principal: number, payment: number, numPayments: number, startPeriod?: number, carryover?: number): 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 {Loan[]} 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 {LoansPaymentSchedule} Various totals and series of data regarding paying off the loans at the payment amount

package/build/lib/payments.js

@@ -4,13 +4,12 @@
  *
  */
 import * as errors from './errors';
-import * as helpers from './helperFunctions';
 /**
  *
  * 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 {ILoan[]} loans The loans to allocate minimum payments
  * @param {number} payment The amount to pay across all loans
  * @returns {number} The extra amount of payment
  */
@@ -32,7 +31,7 @@ export function determineExtraPayment(loans, payment) {
  * @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
  * @param {number} carryover An additional amount to pay towards a loan, used when a residual amount is available from paying off the previous loan this period
- * @returns {Array<AmortizationRecord>} The amortization schdule for the number of payments of payment made to the loan from the provided start period
+ * @returns {AmortizationRecord[]} The amortization schdule for the number of payments of payment made to the loan from the provided start period
  */
 export function amortizePayments(loan, principal, payment, numPayments, startPeriod = 0, carryover = 0) {
     if (payment === null) {
@@ -63,7 +62,7 @@ export function amortizePayments(loan, principal, payment, numPayments, startPer
  *
  * 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 {Loan[]} 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 {LoansPaymentSchedule} Various totals and series of data regarding paying off the loans at the payment amount
@@ -71,10 +70,10 @@ export function amortizePayments(loan, principal, payment, numPayments, startPer
  */
 export function payLoans(loans, payment, reduceMinimum = false) {
     let monthlyPayment = payment;
-    const paymentData = {};
+    const paymentSchedule = {};
     const loanPrincipalsRemaining = {};
     loans.forEach((loan) => {
-        paymentData[loan.id] = {
+        paymentSchedule[loan.id] = {
             lifetimeInterest: 0,
             lifetimePrincipal: loan.currentBalance,
             amortizationSchedule: []
@@ -91,29 +90,33 @@ export function payLoans(loans, payment, reduceMinimum = false) {
         const firstLoanPayment = firstLoan.minPayment +
             determineExtraPayment(loans.slice(paidLoans), monthlyPayment);
         const firstLoanPrincipalRemaining = loanPrincipalsRemaining[firstLoan.id];
-        const periodsToPay = helpers.numPaymentsToZero(firstLoanPrincipalRemaining, firstLoanPayment, firstLoan.periodicRate);
-        const firstLoanPaidPeriods = amortizePayments(firstLoan, firstLoanPrincipalRemaining, firstLoanPayment, periodsToPay, periodsElapsed);
+        const periodsToPay = firstLoan.numPaymentsToZero(firstLoanPayment, firstLoanPrincipalRemaining);
+        const firstLoanAmortizedPayments = amortizePayments(firstLoan, firstLoanPrincipalRemaining, firstLoanPayment, periodsToPay, periodsElapsed);
         const firstLoanCarryover = firstLoanPayment - (firstLoan.principalRemaining(periodsToPay - 1, firstLoanPayment, firstLoanPrincipalRemaining) + firstLoan.accrueInterest(firstLoan.principalRemaining(periodsToPay - 1, firstLoanPayment, firstLoanPrincipalRemaining)));
-        paymentData[firstLoan.id].amortizationSchedule = [
-            ...paymentData[firstLoan.id].amortizationSchedule,
-            ...firstLoanPaidPeriods
+        paymentSchedule[firstLoan.id].amortizationSchedule = [
+            ...paymentSchedule[firstLoan.id].amortizationSchedule,
+            ...firstLoanAmortizedPayments
         ];
         totalAmortizationSchedule = [
             ...totalAmortizationSchedule,
-            ...firstLoanPaidPeriods
+            ...firstLoanAmortizedPayments
         ];
         paidLoans += 1;
         // handle calculating information for the rest of the loans
         loans.slice(paidLoans).forEach((loan, index) => {
             const loanPrincipalRemaining = loanPrincipalsRemaining[loan.id];
-            const paidPeriods = amortizePayments(loan, loanPrincipalRemaining, loan.minPayment, Math.min(periodsToPay, helpers.numPaymentsToZero(loanPrincipalRemaining, loan.minPayment, loan.periodicRate)), periodsElapsed, (index === 0 && !reduceMinimum) ? firstLoanCarryover : 0);
-            paymentData[loan.id].amortizationSchedule = [
-                ...paymentData[loan.id].amortizationSchedule,
-                ...paidPeriods,
+            const loanAmortizedPayments = amortizePayments(loan, loanPrincipalRemaining, loan.minPayment, Math.min(periodsToPay, loan.numPaymentsToZero(loan.minPayment, loanPrincipalRemaining)), periodsElapsed, 
+            // bug
+            // when loan 1 is paid off with overkill on the final payment,
+            // loan 2 is not getting the extra over the global minimum for that payment
+            // i.e. needs to trickle down to #2
+            (index === 0 && !reduceMinimum) ? firstLoanCarryover : 0);
+            paymentSchedule[loan.id].amortizationSchedule = [
+                ...paymentSchedule[loan.id].amortizationSchedule,
+                ...loanAmortizedPayments,
             ];
-            loanPrincipalsRemaining[loan.id] = paymentData[loan.id].amortizationSchedule[paymentData[loan.id].amortizationSchedule.length - 1].principalRemaining;
             totalAmortizationSchedule = totalAmortizationSchedule.map((element) => {
-                const matchedInnerElement = paidPeriods.find((innerElement) => innerElement.period === element.period);
+                const matchedInnerElement = loanAmortizedPayments.find((innerElement) => innerElement.period === element.period);
                 return (matchedInnerElement != null)
                     ? {
                         period: element.period,
@@ -124,6 +127,7 @@ export function payLoans(loans, payment, reduceMinimum = false) {
                     }
                     : element;
             });
+            loanPrincipalsRemaining[loan.id] = paymentSchedule[loan.id].amortizationSchedule[paymentSchedule[loan.id].amortizationSchedule.length - 1].principalRemaining;
         });
         if (reduceMinimum) {
             monthlyPayment -= firstLoan.minPayment;
@@ -131,16 +135,16 @@ export function payLoans(loans, payment, reduceMinimum = false) {
         periodsElapsed += periodsToPay;
     }
     for (const loan of loans) {
-        const loanLifetimeInterest = (paymentData[loan.id].amortizationSchedule.reduce((lifetimeInterest, curval) => lifetimeInterest + curval.interest, 0));
-        paymentData[loan.id].lifetimeInterest = loanLifetimeInterest;
-        paymentData[loan.id].lifetimePrincipal = loan.principal;
+        const loanLifetimeInterest = (paymentSchedule[loan.id].amortizationSchedule.reduce((lifetimeInterest, curval) => lifetimeInterest + curval.interest, 0));
+        paymentSchedule[loan.id].lifetimeInterest = loanLifetimeInterest;
+        paymentSchedule[loan.id].lifetimePrincipal = loan.principal;
         totalLifetimeInterest += loanLifetimeInterest;
-        totalLifetimePrincipal += loan.principal;
+        totalLifetimePrincipal += loan.currentBalance;
     }
-    paymentData.totals = {
+    paymentSchedule.totals = {
         lifetimeInterest: totalLifetimeInterest,
         lifetimePrincipal: totalLifetimePrincipal,
         amortizationSchedule: totalAmortizationSchedule
     };
-    return paymentData;
+    return paymentSchedule;
 }

package/build/lib/sorting.d.ts

@@ -1,31 +1,31 @@
 /**
  *
- * This file contains functions for sorting Arrays of Loans on certain attributes
+ * This file contains functions for sorting Arrays of ILoans on certain attributes
  *
  */
-import { Loan } from './loan';
-type avalanche = (loan1: Loan, loan2: Loan) => number;
-type snowball = (loan1: Loan, loan2: Loan) => number;
+import { ILoan } from './loan';
+type avalanche = (loan1: ILoan, loan2: ILoan) => number;
+type snowball = (loan1: ILoan, loan2: ILoan) => number;
 type sortFunction = avalanche | snowball;
 /**
  * Sorts loans descending by interest rate
- * @param {Loan} loan1 A loan to be comapred
- * @param {Loan} loan2 A loan to be comapred
+ * @param {ILoan} loan1 A loan to be compared
+ * @param {ILoan} loan2 A loan to be comapred
  * @returns {number} the order in which to sort the loans in descending interest rate
  */
-export declare function avalanche(loan1: Loan, loan2: Loan): number;
+export declare function avalanche(loan1: ILoan, loan2: ILoan): number;
 /**
  * Sorts loans ascending by principal
- * @param {Loan} loan1 A loan to be compared
- * @param {Loan} loan2 A loan to be compared
+ * @param {ILoan} loan1 A loan to be compared
+ * @param {ILoan} loan2 A loan to be compared
  * @returns {number} the order in which to sort the loans in ascending princpal
  */
-export declare function snowball(loan1: Loan, loan2: Loan): number;
+export declare function snowball(loan1: ILoan, loan2: ILoan): number;
 /**
- * Sorts an array of loans using the provided sortFunc
- * @param {Array<Loan>} loans The loans to sort
- * @param {function} sortFunc The algorithm to sort the loans with
+ * Sorts an array of loans using the provided sortFunction
+ * @param {ILoan[]} loans The loans to sort
+ * @param {function} sortFunction The algorithm to sort the loans with
  * @returns The sorted array loans
  */
-export declare function sortLoans(loans: Loan[], sortFunction: sortFunction): Loan[];
+export declare function sortLoans(loans: ILoan[], sortFunction: sortFunction): ILoan[];
 export {};

package/build/lib/sorting.js

@@ -1,12 +1,12 @@
 /**
  *
- * This file contains functions for sorting Arrays of Loans on certain attributes
+ * This file contains functions for sorting Arrays of ILoans on certain attributes
  *
  */
 /**
  * Sorts loans descending by interest rate
- * @param {Loan} loan1 A loan to be comapred
- * @param {Loan} loan2 A loan to be comapred
+ * @param {ILoan} loan1 A loan to be compared
+ * @param {ILoan} loan2 A loan to be comapred
  * @returns {number} the order in which to sort the loans in descending interest rate
  */
 export function avalanche(loan1, loan2) {
@@ -14,17 +14,17 @@ export function avalanche(loan1, loan2) {
 }
 /**
  * Sorts loans ascending by principal
- * @param {Loan} loan1 A loan to be compared
- * @param {Loan} loan2 A loan to be compared
+ * @param {ILoan} loan1 A loan to be compared
+ * @param {ILoan} loan2 A loan to be compared
  * @returns {number} the order in which to sort the loans in ascending princpal
  */
 export function snowball(loan1, loan2) {
     return loan1.currentBalance - loan2.currentBalance;
 }
 /**
- * Sorts an array of loans using the provided sortFunc
- * @param {Array<Loan>} loans The loans to sort
- * @param {function} sortFunc The algorithm to sort the loans with
+ * Sorts an array of loans using the provided sortFunction
+ * @param {ILoan[]} loans The loans to sort
+ * @param {function} sortFunction The algorithm to sort the loans with
  * @returns The sorted array loans
  */
 export function sortLoans(loans, sortFunction) {