moneyfunx 1.4.0 → 2.1.0

package/README.md

@@ -4,4 +4,6 @@
 MoneyFunx is a small library of functions for financial computations, with a focus on personal finance
 
 ## Upcoming features
-- Refinancing calcuations
+- Investment library
+    - drawdown/retirement analysis across instruments
+        - "How long can I afford to live on $X (gross|net) per year?"

package/build/index.d.ts

@@ -1,7 +1,10 @@
-export { TOTALS } from './lib/constants';
-export { PaymentTooLowError } from './lib/errors';
-export { calculateMinPayment, numPaymentsToZero, principalRemaining, interestPaid, } from './lib/helperFunctions';
-export { ILoan, Loan } from './lib/loan';
-export { determineExtraPayment, amortizePayments, payLoans, } from './lib/payments';
-export { AmortizationRecord, LoansPaymentSchedule, LoanPrincipals, PaymentSchedule, } from './lib/paymentTypes';
-export { snowball, avalanche, sortLoans } from './lib/sorting';
+export { MAX_DURATION_YEARS, TOTALS, } from './lib/constants';
+export { NegativeContributionError, PaymentTooLowError } from './lib/errors';
+export { calculateMinPayment, numPaymentsToZero, principalRemaining, interestPaid, } from './lib/debt/helperFunctions';
+export { amortizeContributions, contributeInstruments, determineExtraContribution, } from './lib/investment/contributions';
+export { ContributionRecord, ContributionSchedule, InstrumentsContributionSchedule, } from './lib/investment/contributionTypes';
+export { IInstrument, Instrument } from './lib/investment/instrument';
+export { ILoan, Loan } from './lib/debt/loan';
+export { determineExtraPayment, amortizePayments, payLoans, } from './lib/debt/payments';
+export { PaymentRecord, LoansPaymentSchedule, LoanPrincipals, PaymentSchedule, } from './lib/debt/paymentTypes';
+export { snowball, avalanche, sortWith } from './lib/shared/sorting';

package/build/index.js

@@ -1,7 +1,9 @@
 // src/index
-export { TOTALS } from './lib/constants';
-export { PaymentTooLowError } from './lib/errors';
-export { calculateMinPayment, numPaymentsToZero, principalRemaining, interestPaid, } from './lib/helperFunctions';
-export { Loan } from './lib/loan';
-export { determineExtraPayment, amortizePayments, payLoans, } from './lib/payments';
-export { snowball, avalanche, sortLoans } from './lib/sorting';
+export { MAX_DURATION_YEARS, TOTALS, } from './lib/constants';
+export { NegativeContributionError, PaymentTooLowError } from './lib/errors';
+export { calculateMinPayment, numPaymentsToZero, principalRemaining, interestPaid, } from './lib/debt/helperFunctions';
+export { amortizeContributions, contributeInstruments, determineExtraContribution, } from './lib/investment/contributions';
+export { Instrument } from './lib/investment/instrument';
+export { Loan } from './lib/debt/loan';
+export { determineExtraPayment, amortizePayments, payLoans, } from './lib/debt/payments';
+export { snowball, avalanche, sortWith } from './lib/shared/sorting';

package/build/lib/constants.d.ts

@@ -1 +1,5 @@
 export declare const TOTALS = "totals";
+export declare const MAX_DURATION_YEARS = 110;
+export declare const MAX_YIELD_FACTOR = 1.4;
+export declare const MIN_GROWTH_FACTOR = 1;
+export declare const MIN_YIELD_FACTOR = 0.45;

package/build/lib/constants.js

@@ -1 +1,7 @@
+// shared constants
 export const TOTALS = 'totals';
+// investment constants
+export const MAX_DURATION_YEARS = 110;
+export const MAX_YIELD_FACTOR = 1.4;
+export const MIN_GROWTH_FACTOR = 1;
+export const MIN_YIELD_FACTOR = 0.45;

package/build/lib/{loan.d.ts → debt/loan.d.ts}

@@ -41,11 +41,12 @@ export declare class Loan implements ILoan {
      * @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} periodsPerYear The number of times the interest accrues in a year
      * @param {number} termInYears The number of years the loan is repaid over
      * @param {number} name The name for the loan
      * @param {number} currentBalance (Optional) The current balance of the loan, if different from the principal
      * @param {number} fees (Optional) The fees on the loan
+     * @returns {Loan}
      */
     constructor(principal: number, annualRate: number, periodsPerYear: number, termInYears: number, name: string, currentBalance?: number, fees?: number);
     /**
@@ -53,6 +54,7 @@ export declare class Loan implements ILoan {
      * 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
+     * @throws {errors.PaymentTooLowError} Throws an error when the payment to a Loan is less than the Loan's minimum payment
      * @returns {number} The validated payment amount
      */
     validatePayment(payment?: number): number;

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

@@ -9,18 +9,19 @@
  * This library contains functions used to in personal financial analysis
  *
  */
-import * as errors from './errors';
+import * as errors from '../errors';
 import * as helpers from './helperFunctions';
 export class Loan {
     /**
      * @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} periodsPerYear The number of times the interest accrues in a year
      * @param {number} termInYears The number of years the loan is repaid over
      * @param {number} name The name for the loan
      * @param {number} currentBalance (Optional) The current balance of the loan, if different from the principal
      * @param {number} fees (Optional) The fees on the loan
+     * @returns {Loan}
      */
     constructor(principal, annualRate, periodsPerYear, termInYears, name, currentBalance, fees) {
         this.id = String(Math.floor(Math.random() * Date.now()));
@@ -40,6 +41,7 @@ export class Loan {
      * 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
+     * @throws {errors.PaymentTooLowError} Throws an error when the payment to a Loan is less than the Loan's minimum payment
      * @returns {number} The validated payment amount
      */
     validatePayment(payment = this.minPayment) {

package/build/lib/{paymentTypes.d.ts → debt/paymentTypes.d.ts}

@@ -1,4 +1,4 @@
-export type AmortizationRecord = {
+export type PaymentRecord = {
     period: number;
     principal: number;
     interest: number;
@@ -7,7 +7,7 @@ export type AmortizationRecord = {
 export type PaymentSchedule = {
     lifetimeInterest: number;
     lifetimePrincipal: number;
-    amortizationSchedule: AmortizationRecord[];
+    amortizationSchedule: PaymentRecord[];
 };
 export type LoansPaymentSchedule = Record<string, PaymentSchedule>;
 export type LoanPrincipals = Record<string, number>;

package/build/lib/{payments.d.ts → debt/payments.d.ts}

@@ -4,7 +4,7 @@
  *
  */
 import type { ILoan, Loan } from './loan';
-import type { AmortizationRecord, LoansPaymentSchedule } from './paymentTypes';
+import type { PaymentRecord, LoansPaymentSchedule } from './paymentTypes';
 /**
  *
  * Calculates the extra amount in a payment after all loans' minimum payments are met
@@ -36,9 +36,9 @@ export declare function determineCarryover(loan: Loan, loanPayment: number, loan
  * @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 {AmortizationRecord[]} The amortization schdule for the number of payments of payment made to the loan from the provided start period
+ * @returns {PaymentRecord[]} The amortization schedule 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[];
+export declare function amortizePayments(loan: Loan, principal: number, payment: number | null, numPayments: number | null, startPeriod?: number, carryover?: number): PaymentRecord[];
 /**
  *
  * Calculates a wealth of information about paying of a set of loans with a total payment amount

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

@@ -3,7 +3,7 @@
  * This file contains functions for computing detailed information on paying loans
  *
  */
-import * as errors from './errors';
+import * as errors from '../errors';
 /**
  *
  * Calculates the extra amount in a payment after all loans' minimum payments are met
@@ -14,7 +14,7 @@ import * as errors from './errors';
  * @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((accumulator, loan) => accumulator + loan.minPayment, 0);
     // hack to get around floating precision adjustments
     if (parseInt((100 * totalMinPayment).toFixed()) > parseInt((100 * payment).toFixed())) {
         throw new errors.PaymentTooLowError(`Payment amount of ${payment} must be greater than ${totalMinPayment}`);
@@ -49,7 +49,7 @@ export function determineCarryover(loan, loanPayment, loanFinalPayment, reduceMi
  * @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 {AmortizationRecord[]} The amortization schdule for the number of payments of payment made to the loan from the provided start period
+ * @returns {PaymentRecord[]} The amortization schedule 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) {
@@ -59,8 +59,8 @@ export function amortizePayments(loan, principal, payment, numPayments, startPer
     if (numPayments === null) {
         numPayments = loan.numPaymentsToZero(payment);
     }
-    let principalRemaining = principal;
     const amortizationSchedule = [];
+    let principalRemaining = principal;
     for (let period = 0; period < numPayments; period++) {
         const interestThisPeriod = loan.accrueInterest(principalRemaining);
         const principalThisPeriod = Math.min((period === numPayments - 1
@@ -94,7 +94,7 @@ export function payLoans(loans, payment, reduceMinimum = false) {
         paymentSchedule[loan.id] = {
             lifetimeInterest: 0,
             lifetimePrincipal: loan.currentBalance,
-            amortizationSchedule: []
+            amortizationSchedule: [],
         };
         loanPrincipalsRemaining[loan.id] = loan.currentBalance;
     });
@@ -149,7 +149,7 @@ export function payLoans(loans, payment, reduceMinimum = false) {
         periodsElapsed += periodsToPay;
     }
     for (const loan of loans) {
-        const loanLifetimeInterest = (paymentSchedule[loan.id].amortizationSchedule.reduce((lifetimeInterest, curval) => lifetimeInterest + curval.interest, 0));
+        const loanLifetimeInterest = (paymentSchedule[loan.id].amortizationSchedule.reduce((lifetimeInterest, record) => lifetimeInterest + record.interest, 0));
         paymentSchedule[loan.id].lifetimeInterest = loanLifetimeInterest;
         paymentSchedule[loan.id].lifetimePrincipal = loan.currentBalance;
         totalLifetimeInterest += loanLifetimeInterest;
@@ -158,7 +158,7 @@ export function payLoans(loans, payment, reduceMinimum = false) {
     paymentSchedule.totals = {
         lifetimeInterest: totalLifetimeInterest,
         lifetimePrincipal: totalLifetimePrincipal,
-        amortizationSchedule: totalAmortizationSchedule
+        amortizationSchedule: totalAmortizationSchedule,
     };
     return paymentSchedule;
 }

package/build/lib/errors.d.ts

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

package/build/lib/errors.js

@@ -5,3 +5,10 @@ export class PaymentTooLowError extends Error {
         this.name = 'PaymentTooLowError';
     }
 }
+export class NegativeContributionError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, NegativeContributionError.prototype);
+        this.name = 'NegativeContributionError';
+    }
+}

package/build/lib/investment/contributionTypes.d.ts

@@ -0,0 +1,31 @@
+/**
+ *
+ * concept of "maximum contribution" (maxContribution)
+ * analogous to a "minimum payment" (minPayment) for a Loan
+ *
+ *
+ *
+ * current UI is
+ * table
+ *  row-> year
+ *  column -> totalAnnualContribution
+ *  cell -> Wealth
+ *
+ *
+ * Want to produce similar to payments.ts:
+ *  determineExtraPayment [carryover after all MAX contributions are fulfilled]
+ *  amortizeContributions ** investigate if possible **
+ *  contributeInvestments [main a la payLoans]
+ */
+export type ContributionRecord = {
+    period: number;
+    contribution: number;
+    growth: number;
+    currentBalance: number;
+};
+export type ContributionSchedule = {
+    lifetimeGrowth: number;
+    lifetimeContribution: number;
+    amortizationSchedule: ContributionRecord[];
+};
+export type InstrumentsContributionSchedule = Record<string, ContributionSchedule>;

package/build/lib/investment/contributionTypes.js

@@ -0,0 +1,20 @@
+/**
+ *
+ * concept of "maximum contribution" (maxContribution)
+ * analogous to a "minimum payment" (minPayment) for a Loan
+ *
+ *
+ *
+ * current UI is
+ * table
+ *  row-> year
+ *  column -> totalAnnualContribution
+ *  cell -> Wealth
+ *
+ *
+ * Want to produce similar to payments.ts:
+ *  determineExtraPayment [carryover after all MAX contributions are fulfilled]
+ *  amortizeContributions ** investigate if possible **
+ *  contributeInvestments [main a la payLoans]
+ */
+export {};

package/build/lib/investment/contributions.d.ts

@@ -0,0 +1,35 @@
+/**
+ *
+ * This file containts functions for computing detailed information on contributing to investments
+ *
+ */
+import type { Instrument } from './instrument';
+import { ContributionRecord, InstrumentsContributionSchedule } from './contributionTypes';
+/**
+ *
+ * @param {IInstrument[]} instruments The instruments to allocate maximum contributions
+ * @param {number} contribution The amount to contribute across all instruments
+ * @returns {number} The extra amount of contribution
+ */
+export declare function determineExtraContribution(instruments: Instrument[], contribution: number): number;
+/**
+ *
+ * Calculates the amortization schedule for an instrument with a contribution
+ *
+ * @param {Instrument} instrument The instrument to amortize contributions for
+ * @param {number} initialBalance The amount invested
+ * @param {number} contribution The amount to contribute to the instrument's balance each period
+ * @param {number} numContributions The number of periods to make contributions to the instrument
+ * @param {boolean} accrueBeforeContribution A flag for ordering operations of accrual (A) and contribution (C)
+ *         true: A -> C
+ *         false: C -> A
+ * @returns {ContributionRecord[]} The amortization schedule for the number of contributions of contribution made to the instrument
+ */
+export declare function amortizeContributions(instrument: Instrument, initialBalance: number, contribution: number | null, numContributions: number, accrueBeforeContribution?: boolean): ContributionRecord[];
+/**
+ *
+ * @param instruments
+ * @param contribution
+ * @returns
+ */
+export declare function contributeInstruments(instruments: Instrument[], contribution: number, yearsToContribute: number, accrueBeforeContribution?: boolean): InstrumentsContributionSchedule;

package/build/lib/investment/contributions.js

@@ -0,0 +1,105 @@
+/**
+ *
+ * This file containts functions for computing detailed information on contributing to investments
+ *
+ */
+import * as constants from '../constants';
+/**
+ *
+ * @param {IInstrument[]} instruments The instruments to allocate maximum contributions
+ * @param {number} contribution The amount to contribute across all instruments
+ * @returns {number} The extra amount of contribution
+ */
+export function determineExtraContribution(instruments, contribution) {
+    const totalMaxPayment = instruments.reduce((accumulator, instrument) => accumulator + instrument.periodicContribution(), 0);
+    return Math.max(contribution - totalMaxPayment, 0);
+}
+/**
+ *
+ * Calculates the amortization schedule for an instrument with a contribution
+ *
+ * @param {Instrument} instrument The instrument to amortize contributions for
+ * @param {number} initialBalance The amount invested
+ * @param {number} contribution The amount to contribute to the instrument's balance each period
+ * @param {number} numContributions The number of periods to make contributions to the instrument
+ * @param {boolean} accrueBeforeContribution A flag for ordering operations of accrual (A) and contribution (C)
+ *         true: A -> C
+ *         false: C -> A
+ * @returns {ContributionRecord[]} The amortization schedule for the number of contributions of contribution made to the instrument
+ */
+export function amortizeContributions(instrument, initialBalance, contribution, numContributions, accrueBeforeContribution = true) {
+    if (contribution === null) {
+        contribution = instrument.annualLimit / instrument.periodsPerYear;
+    }
+    const amortizationSchedule = [];
+    let ytd = 0;
+    let currentBalance = initialBalance;
+    numContributions = Math.min(numContributions, constants.MAX_DURATION_YEARS * instrument.periodsPerYear);
+    for (let period = 0; period < numContributions; period++) {
+        const contributionThisPeriod = instrument.validateContribution(contribution, ytd);
+        let interestThisPeriod;
+        if (accrueBeforeContribution) {
+            interestThisPeriod = instrument.accrueInterest(currentBalance);
+            currentBalance += contributionThisPeriod + interestThisPeriod;
+        }
+        else {
+            currentBalance += contributionThisPeriod;
+            interestThisPeriod = instrument.accrueInterest(currentBalance);
+            currentBalance += interestThisPeriod;
+        }
+        amortizationSchedule.push({
+            period: period + 1,
+            contribution: contributionThisPeriod,
+            growth: interestThisPeriod,
+            currentBalance,
+        });
+        ytd = (period + 1) % instrument.periodsPerYear ? (ytd + contributionThisPeriod) : 0;
+    }
+    return amortizationSchedule;
+}
+/**
+ *
+ * @param instruments
+ * @param contribution
+ * @returns
+ */
+export function contributeInstruments(instruments, contribution, yearsToContribute, accrueBeforeContribution = true) {
+    let monthlyContribution = contribution;
+    const contributionSchedule = {};
+    let totalLifetimeContribution = 0;
+    let totalLifetimeGrowth = 0;
+    let totalAmortizationSchedule = [];
+    for (const instrument of instruments) {
+        const instrumentContributions = amortizeContributions(instrument, instrument.currentBalance, null, yearsToContribute * instrument.periodsPerYear, accrueBeforeContribution);
+        const instrumentLifetimeContribution = instrumentContributions.reduce((lifetimeContribution, record) => lifetimeContribution + record.contribution, 0);
+        const instrumentLifetimeGrowth = instrumentContributions.reduce((lifetimeGrowth, record) => lifetimeGrowth + record.growth, 0);
+        contributionSchedule[instrument.id] = {
+            lifetimeContribution: instrument.currentBalance + instrumentLifetimeContribution,
+            lifetimeGrowth: instrumentLifetimeGrowth,
+            amortizationSchedule: instrumentContributions,
+        };
+        totalLifetimeContribution += (instrument.currentBalance + instrumentLifetimeContribution);
+        totalLifetimeGrowth += instrumentLifetimeGrowth;
+        // ternary handles base case of an empty list
+        // naively stole this from payments.ts
+        // need to create a new algo to combine
+        totalAmortizationSchedule = totalAmortizationSchedule.length ? (totalAmortizationSchedule.map((element) => {
+            const matchedInnerElement = instrumentContributions.find((innerElement) => innerElement.period === element.period);
+            return (matchedInnerElement != null)
+                ? {
+                    period: element.period,
+                    contribution: element.contribution + matchedInnerElement.contribution,
+                    growth: element.growth + matchedInnerElement.growth,
+                    currentBalance: element.currentBalance +
+                        matchedInnerElement.currentBalance
+                }
+                : element;
+        })) : instrumentContributions;
+    }
+    contributionSchedule.totals = {
+        lifetimeContribution: totalLifetimeContribution,
+        lifetimeGrowth: totalLifetimeGrowth,
+        amortizationSchedule: totalAmortizationSchedule,
+    };
+    return contributionSchedule;
+}

package/build/lib/investment/instrument.d.ts

@@ -0,0 +1,51 @@
+export interface IInstrument {
+    id: string;
+    name: string;
+    currentBalance: number;
+    annualRate: number;
+    periodsPerYear: number;
+    periodicRate: number;
+    annualLimit: number;
+}
+export declare class Instrument implements IInstrument {
+    id: string;
+    name: string;
+    currentBalance: number;
+    annualRate: number;
+    periodsPerYear: number;
+    periodicRate: number;
+    annualLimit: number;
+    /**
+     *
+     * @constructor
+     * @param {number} currentBalance The current balance of the instrument
+     * @param {Function} annualRate  The yearly rate the instrument accrues interest at (simplest case is a closure returning a constant)
+     * @param {number} periodsPerYear The number of times the interest accrues in a year
+     * @param {string} name The name for the instrument
+     * @param {Function} annualLimit (Optional) The maximum amount of money contributable to the instrument in a single year (simplest case is a closure returning a constant)
+     * @returns {Instrument}
+     */
+    constructor(currentBalance: number, annualRate: number, periodsPerYear: number, name: string, annualLimit?: number);
+    /**
+     *
+     * @param {number} contribution The amount to contribute to the instrument
+     * @param {number} yearToDate The total amount contributed year-to-date on the instrument
+     * @throws {errors.NegativeContributionError} Throws an error when the contribution is less than zero
+     * @returns {number} The validated contribution amount
+     */
+    validateContribution(contribution: number, yearToDate: number): number;
+    /**
+     * Helper to calculate the periodic contribution for an instrument
+     * If the instrument does not have an annual limit, returns 0
+     *
+     * @returns {number} the amortized "max" contribution for a period
+     */
+    periodicContribution(): number;
+    /**
+     *
+     * Calculates the amount of interest accrued in a period on a provided principal
+     * @param {number} principal The amunt of money owed on an instrument
+     * @returns {number} The amount of interest accrued in one period
+     */
+    accrueInterest(principal?: number): number;
+}

package/build/lib/investment/instrument.js

@@ -0,0 +1,59 @@
+import * as errors from "../errors";
+export class Instrument {
+    /**
+     *
+     * @constructor
+     * @param {number} currentBalance The current balance of the instrument
+     * @param {Function} annualRate  The yearly rate the instrument accrues interest at (simplest case is a closure returning a constant)
+     * @param {number} periodsPerYear The number of times the interest accrues in a year
+     * @param {string} name The name for the instrument
+     * @param {Function} annualLimit (Optional) The maximum amount of money contributable to the instrument in a single year (simplest case is a closure returning a constant)
+     * @returns {Instrument}
+     */
+    constructor(currentBalance, annualRate, periodsPerYear, name, annualLimit = 0) {
+        this.id = String(Math.floor(Math.random() * Date.now()));
+        this.name = name;
+        this.currentBalance = currentBalance;
+        this.annualRate = annualRate;
+        this.periodsPerYear = periodsPerYear;
+        this.periodicRate = this.annualRate / this.periodsPerYear;
+        this.annualLimit = annualLimit;
+    }
+    /**
+     *
+     * @param {number} contribution The amount to contribute to the instrument
+     * @param {number} yearToDate The total amount contributed year-to-date on the instrument
+     * @throws {errors.NegativeContributionError} Throws an error when the contribution is less than zero
+     * @returns {number} The validated contribution amount
+     */
+    validateContribution(contribution, yearToDate) {
+        if (contribution < 0) {
+            throw new errors.NegativeContributionError(`contribution of ${contribution} must be greater than/equal to zero`);
+        }
+        if (this.annualLimit) {
+            return Math.min(Math.max(this.annualLimit - yearToDate, 0), contribution);
+        }
+        return contribution;
+    }
+    /**
+     * Helper to calculate the periodic contribution for an instrument
+     * If the instrument does not have an annual limit, returns 0
+     *
+     * @returns {number} the amortized "max" contribution for a period
+     */
+    periodicContribution() {
+        if (this.annualLimit) {
+            return this.annualLimit / this.periodsPerYear;
+        }
+        return 0;
+    }
+    /**
+     *
+     * Calculates the amount of interest accrued in a period on a provided principal
+     * @param {number} principal The amunt of money owed on an instrument
+     * @returns {number} The amount of interest accrued in one period
+     */
+    accrueInterest(principal = this.currentBalance) {
+        return principal * this.periodicRate;
+    }
+}

package/build/lib/shared/sorting.d.ts

@@ -0,0 +1,34 @@
+/**
+ *
+ * This file contains functions for sorting Arrays of ILoans or IInstruments on certain attributes
+ *
+ */
+type HasRateAndBalance = {
+    annualRate: number;
+    currentBalance: number;
+};
+type avalanche = (obj1: HasRateAndBalance, obj2: HasRateAndBalance) => number;
+type snowball = (obj1: HasRateAndBalance, obj2: HasRateAndBalance) => number;
+type sortFunction = avalanche | snowball;
+/**
+ * Sorts descending by interest rate
+ * @param {HasRateAndBalance} obj1
+ * @param {HasRateAndBalance} obj2
+ * @returns {number} the order in which to sort the objects in descending interestRate
+ */
+export declare function avalanche(obj1: HasRateAndBalance, obj2: HasRateAndBalance): number;
+/**
+ * Sorts ascending by principal
+ * @param {HasRateAndBalance} obj1
+ * @param {HasRateAndBalanceILoan} obj2
+ * @returns {number} the order in which to sort the objects in ascending currentBalance
+ */
+export declare function snowball(obj1: HasRateAndBalance, obj2: HasRateAndBalance): number;
+/**
+ * Sorts a collection (<HasRateAndBalalnce>) using the provided sortFunction
+ * @param {HasRateAndBalance[]} sortable The collection to sort
+ * @param {function} sortFunction The algorithm to sort the collection with
+ * @returns The sorted collection
+ */
+export declare function sortWith(sortable: HasRateAndBalance[], sortFunction: sortFunction): HasRateAndBalance[];
+export {};

package/build/lib/shared/sorting.js

@@ -0,0 +1,32 @@
+/**
+ *
+ * This file contains functions for sorting Arrays of ILoans or IInstruments on certain attributes
+ *
+ */
+/**
+ * Sorts descending by interest rate
+ * @param {HasRateAndBalance} obj1
+ * @param {HasRateAndBalance} obj2
+ * @returns {number} the order in which to sort the objects in descending interestRate
+ */
+export function avalanche(obj1, obj2) {
+    return obj2.annualRate - obj1.annualRate;
+}
+/**
+ * Sorts ascending by principal
+ * @param {HasRateAndBalance} obj1
+ * @param {HasRateAndBalanceILoan} obj2
+ * @returns {number} the order in which to sort the objects in ascending currentBalance
+ */
+export function snowball(obj1, obj2) {
+    return obj1.currentBalance - obj2.currentBalance;
+}
+/**
+ * Sorts a collection (<HasRateAndBalalnce>) using the provided sortFunction
+ * @param {HasRateAndBalance[]} sortable The collection to sort
+ * @param {function} sortFunction The algorithm to sort the collection with
+ * @returns The sorted collection
+ */
+export function sortWith(sortable, sortFunction) {
+    return sortable.sort(sortFunction);
+}