moneyfunx 3.0.9 → 3.0.11

package/build/lib/debt/payments.d.ts

@@ -32,8 +32,8 @@ export declare function determineCarryover(loan: Loan, loanPayment: number, loan
  *
  * @param {Loan} loan The loan to amortize payments for
  * @param {number} principal The amount borrowed
- * @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|null} payment The amount to pay to the loan's balance each period
+ * @param {number|null} 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 {PaymentRecord[]} The amortization schedule for the number of payments of payment made to the loan from the provided start period

package/build/lib/debt/payments.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"payments.d.ts","sourceRoot":"","sources":["../../../src/lib/debt/payments.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,KAAK,EACV,aAAa,EAEb,oBAAoB,EACrB,MAAM,yBAAyB,CAAC;AAEjC;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,KAAK,EAAE,EACd,OAAO,EAAE,MAAM,GACd,MAAM,CAYR;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,IAAI,EACV,WAAW,EAAE,MAAM,EACnB,gBAAgB,EAAE,MAAM,EACxB,aAAa,EAAE,OAAO,GACrB,MAAM,CAOR;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,IAAI,EACV,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,GAAC,IAAI,EACpB,WAAW,EAAE,MAAM,GAAC,IAAI,EACxB,WAAW,GAAE,MAAU,EACvB,SAAS,GAAE,MAAU,GACpB,aAAa,EAAE,CA+BjB;AAED;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,IAAI,EAAE,EACb,OAAO,EAAE,MAAM,EACf,aAAa,GAAE,OAAe,GAC7B,oBAAoB,CAqItB"}
+{"version":3,"file":"payments.d.ts","sourceRoot":"","sources":["../../../src/lib/debt/payments.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,KAAK,EACV,aAAa,EAEb,oBAAoB,EACrB,MAAM,yBAAyB,CAAC;AAEjC;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,KAAK,EAAE,EACd,OAAO,EAAE,MAAM,GACd,MAAM,CAYR;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,IAAI,EACV,WAAW,EAAE,MAAM,EACnB,gBAAgB,EAAE,MAAM,EACxB,aAAa,EAAE,OAAO,GACrB,MAAM,CAOR;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,IAAI,EACV,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,GAAG,IAAI,EACtB,WAAW,EAAE,MAAM,GAAG,IAAI,EAC1B,WAAW,GAAE,MAAU,EACvB,SAAS,GAAE,MAAU,GACpB,aAAa,EAAE,CA2BjB;AAED;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,IAAI,EAAE,EACb,OAAO,EAAE,MAAM,EACf,aAAa,GAAE,OAAe,GAC7B,oBAAoB,CA6ItB"}

package/build/lib/debt/payments.js

@@ -4,6 +4,7 @@
  *
  */
 import * as errors from '../errors.js';
+import { TOTALS } from '../constants.js';
 /**
  *
  * Calculates the extra amount in a payment after all loans' minimum payments are met
@@ -45,27 +46,24 @@ export function determineCarryover(loan, loanPayment, loanFinalPayment, reduceMi
  *
  * @param {Loan} loan The loan to amortize payments for
  * @param {number} principal The amount borrowed
- * @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|null} payment The amount to pay to the loan's balance each period
+ * @param {number|null} 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 {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) {
-        payment = loan.minPayment;
-    }
-    payment = loan.validatePayment(payment);
-    if (numPayments === null) {
-        numPayments = loan.numPaymentsToZero(payment);
-    }
+    // Strict null check handling
+    let actualPayment = (payment !== null) ? payment : loan.minPayment;
+    actualPayment = loan.validatePayment(actualPayment);
+    let actualNumPayments = (numPayments !== null) ? numPayments : loan.numPaymentsToZero(actualPayment);
     const amortizationSchedule = [];
     let principalRemaining = principal;
-    for (let period = 0; period < numPayments; period++) {
+    for (let period = 0; period < actualNumPayments; period++) {
         const interestThisPeriod = loan.accrueInterest(principalRemaining);
-        const principalThisPeriod = Math.min((period === numPayments - 1
-            ? payment + carryover
-            : payment) - interestThisPeriod, principalRemaining);
+        const principalThisPeriod = Math.min((period === actualNumPayments - 1
+            ? actualPayment + carryover
+            : actualPayment) - interestThisPeriod, principalRemaining);
         principalRemaining -= principalThisPeriod;
         amortizationSchedule.push({
             period: startPeriod + period + 1,
@@ -104,50 +102,76 @@ export function payLoans(loans, payment, reduceMinimum = false) {
     let totalLifetimePrincipal = 0;
     let totalAmortizationSchedule = [];
     while (paidLoans < loans.length) {
-        const firstLoan = loans.slice(paidLoans)[0];
+        const activeLoans = loans.slice(paidLoans);
+        const firstLoan = activeLoans[0];
+        // 1. Determine the "Driver" parameters (the loan being paid off in this chunk)
         const firstLoanPayment = (firstLoan.minPayment +
-            determineExtraPayment(loans.slice(paidLoans), monthlyPayment));
+            determineExtraPayment(activeLoans, monthlyPayment));
         const firstLoanPrincipalRemaining = loanPrincipalsRemaining[firstLoan.id];
+        // How long does this chunk last?
         const periodsToPay = firstLoan.numPaymentsToZero(firstLoanPayment, firstLoanPrincipalRemaining);
-        const firstLoanAmortizedPayments = amortizePayments(firstLoan, firstLoanPrincipalRemaining, firstLoanPayment, periodsToPay, periodsElapsed);
-        const firstLoanFinalPayment = firstLoan.principalRemaining(periodsToPay - 1, firstLoanPayment, firstLoanPrincipalRemaining) + firstLoan.accrueInterest(firstLoan.principalRemaining(periodsToPay - 1, firstLoanPayment, firstLoanPrincipalRemaining));
-        paymentSchedule[firstLoan.id].amortizationSchedule = [
-            ...paymentSchedule[firstLoan.id].amortizationSchedule,
-            ...firstLoanAmortizedPayments
-        ];
-        totalAmortizationSchedule = [
-            ...totalAmortizationSchedule,
-            ...firstLoanAmortizedPayments
-        ];
-        paidLoans += 1;
-        if (reduceMinimum) {
-            monthlyPayment -= firstLoan.minPayment;
-        }
-        ;
-        // handle calculating information for the rest of the loans
-        loans.slice(paidLoans).forEach((loan, index) => {
+        // 2. Calculate the Final Payment specifics for the driver loan
+        //    (Needed for carryover calculation)
+        const finalPrincipal = firstLoan.principalRemaining(periodsToPay - 1, firstLoanPayment, firstLoanPrincipalRemaining);
+        const firstLoanFinalPayment = finalPrincipal + firstLoan.accrueInterest(finalPrincipal);
+        // 3. Process ALL active loans for this chunk of time
+        activeLoans.forEach((loan, index) => {
+            const isDriverLoan = index === 0;
             const loanPrincipalRemaining = loanPrincipalsRemaining[loan.id];
-            const loanAmortizedPayments = amortizePayments(loan, loanPrincipalRemaining, loan.minPayment, Math.min(periodsToPay, loan.numPaymentsToZero(loan.minPayment, loanPrincipalRemaining)), periodsElapsed, (index === 0 ? determineCarryover(firstLoan, firstLoanPayment, firstLoanFinalPayment, reduceMinimum) : 0));
+            // Determine payment amount: Driver gets extra, others get minimum
+            const paymentAmount = isDriverLoan ? firstLoanPayment : loan.minPayment;
+            // Determine duration: Others are capped by the Driver's time-to-zero
+            const duration = isDriverLoan
+                ? periodsToPay
+                : Math.min(periodsToPay, loan.numPaymentsToZero(loan.minPayment, loanPrincipalRemaining));
+            // Determine carryover: Only applies to the SECOND loan (index 1), derived from Driver
+            const carryoverAmount = (index === 1)
+                ? determineCarryover(firstLoan, firstLoanPayment, firstLoanFinalPayment, reduceMinimum)
+                : 0;
+            const loanAmortizedPayments = amortizePayments(loan, loanPrincipalRemaining, paymentAmount, duration, periodsElapsed, carryoverAmount);
+            // A. Append to individual loan schedule
             paymentSchedule[loan.id].amortizationSchedule = [
                 ...paymentSchedule[loan.id].amortizationSchedule,
                 ...loanAmortizedPayments,
             ];
-            totalAmortizationSchedule = totalAmortizationSchedule.map((element) => {
-                const matchedInnerElement = loanAmortizedPayments.find((innerElement) => innerElement.period === element.period);
-                return (matchedInnerElement != null)
-                    ? {
-                        period: element.period,
-                        principal: element.principal + matchedInnerElement.principal,
-                        interest: element.interest + matchedInnerElement.interest,
-                        principalRemaining: element.principalRemaining +
-                            matchedInnerElement.principalRemaining
-                    }
-                    : element;
-            });
-            loanPrincipalsRemaining[loan.id] = paymentSchedule[loan.id].amortizationSchedule[paymentSchedule[loan.id].amortizationSchedule.length - 1].principalRemaining;
+            // B. Merge into Total Schedule
+            if (isDriverLoan) {
+                // The Driver extends the timeline. We append its records to initialize the new period slots in Totals.
+                totalAmortizationSchedule = [
+                    ...totalAmortizationSchedule,
+                    ...loanAmortizedPayments
+                ];
+            }
+            else {
+                // Followers merge into the existing slots created by the Driver.
+                // We only map over the NEW segment of the total schedule to avoid re-scanning history (optional optimization),
+                // but for safety/simplicity we map the whole structure and match by period.
+                totalAmortizationSchedule = totalAmortizationSchedule.map((element) => {
+                    const matchedInnerElement = loanAmortizedPayments.find((innerElement) => innerElement.period === element.period);
+                    return (matchedInnerElement != null)
+                        ? {
+                            period: element.period,
+                            principal: element.principal + matchedInnerElement.principal,
+                            interest: element.interest + matchedInnerElement.interest,
+                            principalRemaining: element.principalRemaining + matchedInnerElement.principalRemaining
+                        }
+                        : element;
+                });
+            }
+            // Update tracking state for next iteration
+            if (paymentSchedule[loan.id].amortizationSchedule.length > 0) {
+                const fullSchedule = paymentSchedule[loan.id].amortizationSchedule;
+                loanPrincipalsRemaining[loan.id] = fullSchedule[fullSchedule.length - 1].principalRemaining;
+            }
         });
+        paidLoans += 1;
         periodsElapsed += periodsToPay;
+        if (reduceMinimum) {
+            monthlyPayment -= firstLoan.minPayment;
+        }
+        ;
     }
+    // Final Totals Calculation
     for (const loan of loans) {
         const loanLifetimeInterest = (paymentSchedule[loan.id].amortizationSchedule.reduce((lifetimeInterest, record) => lifetimeInterest + record.interest, 0));
         paymentSchedule[loan.id].lifetimeInterest = loanLifetimeInterest;
@@ -155,7 +179,7 @@ export function payLoans(loans, payment, reduceMinimum = false) {
         totalLifetimeInterest += loanLifetimeInterest;
         totalLifetimePrincipal += loan.currentBalance;
     }
-    paymentSchedule.totals = {
+    paymentSchedule[TOTALS] = {
         lifetimeInterest: totalLifetimeInterest,
         lifetimePrincipal: totalLifetimePrincipal,
         amortizationSchedule: totalAmortizationSchedule,

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

@@ -4,7 +4,7 @@
  *
  */
 import type { Instrument } from '../investment/instrument.js';
-import { ContributionRecord, InstrumentsContributionSchedule } from '../investment/contributionTypes.js';
+import type { ContributionRecord, InstrumentsContributionSchedule } from '../investment/contributionTypes.js';
 /**
  *
  * @param {IInstrument[]} instruments The instruments to allocate maximum contributions
@@ -19,8 +19,8 @@ export declare function determineExtraContribution(instruments: Instrument[], co
  * @param {number} contribution The amount to contribute to the instrument's balance
  * @param {number[int]} startPeriod The initial offset for period values
  * @param {boolean} accrueBeforeContribution A flag for ordering operations of accrual (A) and contribution (C)
- *         true: A -> C
- *         false: C -> A
+ * true: A -> C
+ * false: C -> A
  * @returns {ContributionRecord} The amortized contribution
  */
 export declare function amortizeContribution(instrument: Instrument, currentBalance: number, contribution: number, startPeriod?: number, accrueBeforeContribution?: boolean): ContributionRecord;
@@ -34,8 +34,8 @@ export declare function amortizeContribution(instrument: Instrument, currentBala
  * @param {number} numContributions The number of periods to make contributions to the instrument
  * @param {number[int]} startPeriod The inital offset for period values
  * @param {boolean} accrueBeforeContribution A flag for ordering operations of accrual (A) and contribution (C)
- *         true: A -> C
- *         false: C -> A
+ * true: A -> C
+ * false: C -> A
  * @returns {ContributionRecord[]} The amortized contributions
  */
 export declare function amortizeContributions(instrument: Instrument, initialBalance: number, contribution: number, numContributions: number, startPeriod?: number, accrueBeforeContribution?: boolean): ContributionRecord[];
@@ -45,8 +45,8 @@ export declare function amortizeContributions(instrument: Instrument, initialBal
  * @param {number} contribution The total amount to contirbute each period
  * @param {number[int]} numContributions The number of periods to contribute
  * @param {boolean} accrueBeforeContribution A flag for ordering operations of accrual (A) and contribution (C)
- *         true: A -> C
- *         false: C -> A
+ * true: A -> C
+ * false: C -> A
  * @returns {InstrumentsContributionSchedule} The amortized contributions for all instruments
  */
 export declare function contributeInstruments(instruments: Instrument[], contribution: number, numContributions: number, accrueBeforeContribution?: boolean): InstrumentsContributionSchedule;

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

@@ -1 +1 @@
-{"version":3,"file":"contributions.d.ts","sourceRoot":"","sources":["../../../src/lib/investment/contributions.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,EACL,kBAAkB,EAClB,+BAA+B,EAGhC,MAAM,oCAAoC,CAAC;AAE5C;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,UAAU,EAAE,EACzB,YAAY,EAAE,MAAM,GACnB,MAAM,CAMR;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,UAAU,EACtB,cAAc,EAAE,MAAM,EACtB,YAAY,EAAE,MAAM,EACpB,WAAW,GAAE,MAAU,EACvB,wBAAwB,GAAE,OAAc,GACvC,kBAAkB,CAgBpB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,UAAU,EACtB,cAAc,EAAE,MAAM,EACtB,YAAY,EAAE,MAAM,EACpB,gBAAgB,EAAE,MAAM,EACxB,WAAW,GAAE,MAAU,EACvB,wBAAwB,GAAE,OAAc,GACvC,kBAAkB,EAAE,CAkBtB;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACnC,WAAW,EAAE,UAAU,EAAE,EACzB,YAAY,EAAE,MAAM,EACpB,gBAAgB,EAAE,MAAM,EACxB,wBAAwB,GAAE,OAAc,GACvC,+BAA+B,CA6FjC"}
+{"version":3,"file":"contributions.d.ts","sourceRoot":"","sources":["../../../src/lib/investment/contributions.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,KAAK,EACV,kBAAkB,EAClB,+BAA+B,EAGhC,MAAM,oCAAoC,CAAC;AAE5C;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,UAAU,EAAE,EACzB,YAAY,EAAE,MAAM,GACnB,MAAM,CAMR;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,UAAU,EACtB,cAAc,EAAE,MAAM,EACtB,YAAY,EAAE,MAAM,EACpB,WAAW,GAAE,MAAU,EACvB,wBAAwB,GAAE,OAAc,GACvC,kBAAkB,CAkBpB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,UAAU,EACtB,cAAc,EAAE,MAAM,EACtB,YAAY,EAAE,MAAM,EACpB,gBAAgB,EAAE,MAAM,EACxB,WAAW,GAAE,MAAU,EACvB,wBAAwB,GAAE,OAAc,GACvC,kBAAkB,EAAE,CAmBtB;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACnC,WAAW,EAAE,UAAU,EAAE,EACzB,YAAY,EAAE,MAAM,EACpB,gBAAgB,EAAE,MAAM,EACxB,wBAAwB,GAAE,OAAc,GACvC,+BAA+B,CAyGjC"}

package/build/lib/investment/contributions.js

@@ -3,6 +3,7 @@
  * This file containts functions for computing detailed information on contributing to investments
  *
  */
+import { TOTALS } from '../constants.js';
 /**
  *
  * @param {IInstrument[]} instruments The instruments to allocate maximum contributions
@@ -21,26 +22,27 @@ export function determineExtraContribution(instruments, contribution) {
  * @param {number} contribution The amount to contribute to the instrument's balance
  * @param {number[int]} startPeriod The initial offset for period values
  * @param {boolean} accrueBeforeContribution A flag for ordering operations of accrual (A) and contribution (C)
- *         true: A -> C
- *         false: C -> A
+ * true: A -> C
+ * false: C -> A
  * @returns {ContributionRecord} The amortized contribution
  */
 export function amortizeContribution(instrument, currentBalance, contribution, startPeriod = 0, accrueBeforeContribution = true) {
     let interestThisPeriod;
+    let newBalance = currentBalance;
     if (accrueBeforeContribution) {
-        interestThisPeriod = instrument.accrueInterest(currentBalance);
-        currentBalance += contribution + interestThisPeriod;
+        interestThisPeriod = instrument.accrueInterest(newBalance);
+        newBalance += contribution + interestThisPeriod;
     }
     else {
-        currentBalance += contribution;
-        interestThisPeriod = instrument.accrueInterest(currentBalance);
-        currentBalance += interestThisPeriod;
+        newBalance += contribution;
+        interestThisPeriod = instrument.accrueInterest(newBalance);
+        newBalance += interestThisPeriod;
     }
     return {
         period: startPeriod + 1,
         contribution: contribution,
         growth: interestThisPeriod,
-        currentBalance,
+        currentBalance: newBalance,
     };
 }
 ;
@@ -54,8 +56,8 @@ export function amortizeContribution(instrument, currentBalance, contribution, s
  * @param {number} numContributions The number of periods to make contributions to the instrument
  * @param {number[int]} startPeriod The inital offset for period values
  * @param {boolean} accrueBeforeContribution A flag for ordering operations of accrual (A) and contribution (C)
- *         true: A -> C
- *         false: C -> A
+ * true: A -> C
+ * false: C -> A
  * @returns {ContributionRecord[]} The amortized contributions
  */
 export function amortizeContributions(instrument, initialBalance, contribution, numContributions, startPeriod = 0, accrueBeforeContribution = true) {
@@ -66,6 +68,7 @@ export function amortizeContributions(instrument, initialBalance, contribution,
         const periodicContribution = instrument.validateContribution(contribution, ytd);
         const record = amortizeContribution(instrument, currentBalance, periodicContribution, period + startPeriod, accrueBeforeContribution);
         currentBalance = record.currentBalance;
+        // Reset YTD every 12 periods
         period % 12 === 0 ? ytd = 0 : ytd += periodicContribution;
         contributionSchedule.push(record);
     }
@@ -78,8 +81,8 @@ export function amortizeContributions(instrument, initialBalance, contribution,
  * @param {number} contribution The total amount to contirbute each period
  * @param {number[int]} numContributions The number of periods to contribute
  * @param {boolean} accrueBeforeContribution A flag for ordering operations of accrual (A) and contribution (C)
- *         true: A -> C
- *         false: C -> A
+ * true: A -> C
+ * false: C -> A
  * @returns {InstrumentsContributionSchedule} The amortized contributions for all instruments
  */
 export function contributeInstruments(instruments, contribution, numContributions, accrueBeforeContribution = true) {
@@ -126,22 +129,37 @@ export function contributeInstruments(instruments, contribution, numContribution
         contributionSchedules[instrument.id].lifetimeGrowth = instrumentLifetimeGrowth;
         totalLifetimeContribution += instrumentLifetimeContribution;
         totalLifetimeGrowth += instrumentLifetimeGrowth;
-        totalAmortizationSchedule = totalAmortizationSchedule.length
-            ? (totalAmortizationSchedule.map((element) => {
-                const matchedInnerElement = instrumentSchedule.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;
-            }))
-            : instrumentSchedule;
+        // Merge totals safely handling varying lengths
+        if (totalAmortizationSchedule.length === 0) {
+            // Initialize with the first instrument's schedule
+            totalAmortizationSchedule = [...instrumentSchedule];
+        }
+        else {
+            // We need to merge. If schedules are different lengths, we map over the longer one.
+            const maxLen = Math.max(totalAmortizationSchedule.length, instrumentSchedule.length);
+            const newTotal = [];
+            for (let i = 0; i < maxLen; i++) {
+                const totalRecord = totalAmortizationSchedule[i];
+                const instrumentRecord = instrumentSchedule[i];
+                if (totalRecord && instrumentRecord) {
+                    newTotal.push({
+                        period: totalRecord.period,
+                        contribution: totalRecord.contribution + instrumentRecord.contribution,
+                        growth: totalRecord.growth + instrumentRecord.growth,
+                        currentBalance: totalRecord.currentBalance + instrumentRecord.currentBalance
+                    });
+                }
+                else if (totalRecord) {
+                    newTotal.push(totalRecord);
+                }
+                else if (instrumentRecord) {
+                    newTotal.push(instrumentRecord);
+                }
+            }
+            totalAmortizationSchedule = newTotal;
+        }
     }
-    contributionSchedules.totals = {
+    contributionSchedules[TOTALS] = {
         lifetimeContribution: totalLifetimeContribution,
         lifetimeGrowth: totalLifetimeGrowth,
         amortizationSchedule: totalAmortizationSchedule,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moneyfunx",
-  "version": "3.0.9",
+  "version": "3.0.11",
   "type": "module",
   "exports": {
     ".": {