claude.ai/public/artifacts/321e55e7-acfa-464f-af55-745d7db60661

import React, { useState, useMemo } from ‘react’;
import { LineChart, Line, XAxis, YAxis, CartesianGrid, Tooltip, Legend, ResponsiveContainer, BarChart, Bar, Area, AreaChart } from ‘recharts’;
import { DollarSign, TrendingUp, Calendar, Target, Building2, Shield, ArrowRightLeft } from ‘lucide-react’;

const IncomeReplacementCalculator = () => {
const [activeTab, setActiveTab] = useState(‘overview’);
const [showPortfolioTheory, setShowPortfolioTheory] = useState(false);

const [inputs, setInputs] = useState({
currentAge: 36,
targetAge: 50,
currentSalary: 75000,
currentPortfolio: 100000,
annualContribution: 20000,
targetAnnualReturn: 8,
dividendYield: 4,
inflationRate: 3,
// Exit Strategy Inputs
realEstateValue: 250000,
realEstateAppreciation: 4,
rentalYield: 6,
exchange1031Age: 42,
// Trust & Tax Inputs
useTrust: true,
trustType: ‘revocable’,
capitalGainsTaxRate: 15,
estateTaxExemption: 13610000,
// Options Strategy
useOptionsStrategy: false,
coveredCallPremium: 2,
optionsFrequency: 12,
// Portfolio Theory Inputs
securitiesVolatility: 15,
realEstateVolatility: 10,
correlationCoefficient: 0.3
});

const handleInputChange = (field, value) => {
setInputs(prev => ({
…prev,
[field]: typeof value === ‘boolean’ ? value : (parseFloat(value) || 0)
}));
};

const calculations = useMemo(() => {
const years = inputs.targetAge – inputs.currentAge;
const yearlyData = [];
const exitStrategyData = [];
const portfolioTheoryData = [];

“`
let portfolio = inputs.currentPortfolio;
let realEstate = inputs.realEstateValue;
let adjustedSalary = inputs.currentSalary;
let exchangedProperty = 0;
let totalTaxDeferred = 0;

// Calculate optimal portfolio weights using Modern Portfolio Theory
const R1 = inputs.targetAnnualReturn; // Securities return
const R2 = inputs.realEstateAppreciation + inputs.rentalYield; // Real estate total return
const sigma1 = inputs.securitiesVolatility; // Securities volatility
const sigma2 = inputs.realEstateVolatility; // Real estate volatility
const rho = inputs.correlationCoefficient; // Correlation

// Generate efficient frontier data points
for (let w1 = 0; w1 <= 1; w1 += 0.05) { const w2 = 1 - w1; // Portfolio return: Rp = w1*R1 + w2*R2 const Rp = w1 * R1 + w2 * R2; // Portfolio variance: σp² = w1²σ1² + w2²σ2² + 2w1w2ρσ1σ2 const varianceP = Math.pow(w1, 2) * Math.pow(sigma1, 2) + Math.pow(w2, 2) * Math.pow(sigma2, 2) + 2 * w1 * w2 * rho * sigma1 * sigma2; const sigmaP = Math.sqrt(varianceP); // Sharpe ratio (assuming risk-free rate of 4%) const riskFreeRate = 4; const sharpeRatio = (Rp - riskFreeRate) / sigmaP; portfolioTheoryData.push({ w1: Math.round(w1 * 100), w2: Math.round(w2 * 100), expectedReturn: Math.round(Rp * 100) / 100, portfolioVolatility: Math.round(sigmaP * 100) / 100, sharpeRatio: Math.round(sharpeRatio * 100) / 100 }); } // Find optimal portfolio (max Sharpe ratio) const optimalPortfolio = portfolioTheoryData.reduce((max, curr) =>
curr.sharpeRatio > max.sharpeRatio ? curr : max
);

for (let year = 0; year <= years; year++) { const age = inputs.currentAge + year; // Salary adjustment adjustedSalary = inputs.currentSalary * Math.pow(1 + inputs.inflationRate / 100, year); // Portfolio growth with contributions if (year > 0) {
portfolio = portfolio * (1 + inputs.targetAnnualReturn / 100) + inputs.annualContribution;
}

// Real estate appreciation
if (year > 0) {
realEstate = realEstate * (1 + inputs.realEstateAppreciation / 100);
}

// 1031 Exchange at specified age
let exchange1031Executed = false;
if (age === inputs.exchange1031Age && exchangedProperty === 0) {
exchange1031Executed = true;
const capitalGain = realEstate – inputs.realEstateValue;
totalTaxDeferred = capitalGain * (inputs.capitalGainsTaxRate / 100);
exchangedProperty = realEstate;
// Assume reinvestment into higher-yielding property
realEstate = realEstate * 1.1; // 10% upgrade
}

// Income calculations
const annualDividendIncome = portfolio * (inputs.dividendYield / 100);
const annualRentalIncome = realEstate * (inputs.rentalYield / 100);

// Options premium if strategy enabled
const optionsPremium = inputs.useOptionsStrategy ?
(portfolio * (inputs.coveredCallPremium / 100)) : 0;

const totalInvestmentIncome = annualDividendIncome + annualRentalIncome + optionsPremium;

// Quarterly and daily breakdowns
const quarterlyIncome = totalInvestmentIncome / 4;
const dailyIncome = totalInvestmentIncome / 252;

// Income replacement percentage
const incomeReplacementPct = (totalInvestmentIncome / adjustedSalary) * 100;

// Required portfolio for full replacement
const requiredPortfolio = adjustedSalary / (inputs.dividendYield / 100);

// Trust considerations
const trustProtectedAssets = inputs.useTrust ? (portfolio + realEstate) : 0;
const estateTaxLiability = Math.max(0, (portfolio + realEstate – inputs.estateTaxExemption) * 0.4);

yearlyData.push({
age,
year,
portfolio: Math.round(portfolio),
realEstate: Math.round(realEstate),
totalAssets: Math.round(portfolio + realEstate),
salary: Math.round(adjustedSalary),
dividendIncome: Math.round(annualDividendIncome),
rentalIncome: Math.round(annualRentalIncome),
optionsPremium: Math.round(optionsPremium),
totalInvestmentIncome: Math.round(totalInvestmentIncome),
incomeReplacementPct: Math.round(incomeReplacementPct * 10) / 10,
requiredPortfolio: Math.round(requiredPortfolio),
gap: Math.round(requiredPortfolio – portfolio),
dailyIncome: Math.round(dailyIncome),
quarterlyIncome: Math.round(quarterlyIncome),
trustProtectedAssets: Math.round(trustProtectedAssets),
estateTaxLiability: Math.round(estateTaxLiability),
exchange1031Executed,
taxDeferred: Math.round(totalTaxDeferred)
});

// Exit strategy milestones
if (incomeReplacementPct >= 50 || incomeReplacementPct >= 75 || incomeReplacementPct >= 100) {
exitStrategyData.push({
age,
milestone: incomeReplacementPct >= 100 ? ‘Full Independence’ :
incomeReplacementPct >= 75 ? ‘Partial Retirement’ :
‘Reduced Hours’,
incomeReplacement: Math.round(incomeReplacementPct),
portfolioValue: Math.round(portfolio + realEstate)
});
}
}

return { yearlyData, exitStrategyData, portfolioTheoryData, optimalPortfolio };
“`

}, [inputs]);

const finalYear = calculations.yearlyData[calculations.yearlyData.length – 1];
const currentYear = calculations.yearlyData[0];

return (

“`

);
};

export default IncomeReplacementCalculator;